1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
//===- BuildEngineTrace.h ---------------------------------------*- C++ -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
#ifndef LLBUILD_CORE_BUILDENGINETRACE_H
#define LLBUILD_CORE_BUILDENGINETRACE_H
#include <string>
#include <unordered_map>
namespace llbuild {
namespace core {
class Rule;
class Task;
/// This class assists in writing build engine tracing information to an
/// external log file, suitable for ex post facto debugging and analysis.
class BuildEngineTrace {
/// The output file pointer.
void* outputPtr = nullptr;
unsigned numNamedTasks = 0;
std::unordered_map<const Task*, std::string> taskNames;
unsigned numNamedRules = 0;
std::unordered_map<const Rule*, std::string> ruleNames;
private:
const char* getTaskName(const Task*);
const char* getRuleName(const Rule*);
public:
BuildEngineTrace();
~BuildEngineTrace();
/// Open an output file for writing, must be called prior to any trace
/// recording, and may only be called once per trace object.
///
/// \returns True on success.
bool open(const std::string& path, std::string* error_out);
/// Close the output file; no subsequest trace recording may be done.
///
/// \returns True on success.
bool close(std::string* error_out);
/// Check if the trace output is open.
bool isOpen() const { return outputPtr != nullptr; }
/// @name Trace Recording APIs
/// @{
/// @name Core Engine Operation
/// @{
void buildStarted();
void handlingBuildInputRequest(const Rule* rule);
void createdTaskForRule(const Task* task, const Rule* rule);
void handlingTaskInputRequest(const Task* task, const Rule* rule);
void pausedInputRequestForRuleScan(const Rule* rule);
void readyingTaskInputRequest(const Task* task, const Rule* rule);
void addedRulePendingTask(const Rule* rule, const Task* task);
void completedTaskInputRequest(const Task* task, const Rule* rule);
void updatedTaskWaitCount(const Task* task, unsigned waitCount);
void unblockedTask(const Task* task);
void readiedTask(const Task* task, const Rule* rule);
void finishedTask(const Task* task, const Rule* rule, bool wasChanged);
void buildEnded();
/// @}
/// @name Dependency Checking
/// @{
void checkingRuleNeedsToRun(const Rule* forRule);
void ruleScheduledForScanning(const Rule* forRule);
void ruleScanningNextInput(const Rule* forRule, const Rule* inputRule);
void ruleScanningDeferredOnInput(const Rule* forRule,
const Rule* inputRule);
void ruleScanningDeferredOnTask(const Rule* forRule,
const Task* inputTask);
void ruleNeedsToRunBecauseNeverBuilt(const Rule* forRule);
void ruleNeedsToRunBecauseSignatureChanged(const Rule* forRule);
void ruleNeedsToRunBecauseInvalidValue(const Rule* forRule);
void ruleNeedsToRunBecauseInputMissing(const Rule* forRule);
void ruleNeedsToRunBecauseInputRebuilt(const Rule* forRule,
const Rule* inputRule);
void ruleDoesNotNeedToRun(const Rule* forRule);
/// @}
/// @name Cycle Resolution
/// @{
void cycleForceRuleNeedsToRun(const Rule* forRule);
void cycleSupplyPriorValue(const Rule* forRule, const Task* toTask);
/// @}
/// @}
};
}
}
#endif
|
