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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
// Copyright 2011 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef NINJA_STATE_H_
#define NINJA_STATE_H_
#include <map>
#include <set>
#include <string>
#include <vector>
#include "eval_env.h"
#include "graph.h"
#include "hash_map.h"
#include "util.h"
struct Edge;
struct Node;
struct Rule;
/// A pool for delayed edges.
/// Pools are scoped to a State. Edges within a State will share Pools. A Pool
/// will keep a count of the total 'weight' of the currently scheduled edges. If
/// a Plan attempts to schedule an Edge which would cause the total weight to
/// exceed the depth of the Pool, the Pool will enqueue the Edge instead of
/// allowing the Plan to schedule it. The Pool will relinquish queued Edges when
/// the total scheduled weight diminishes enough (i.e. when a scheduled edge
/// completes).
struct Pool {
Pool(const std::string& name, int depth)
: name_(name), current_use_(0), depth_(depth), delayed_() {}
// A depth of 0 is infinite
bool is_valid() const { return depth_ >= 0; }
int depth() const { return depth_; }
const std::string& name() const { return name_; }
int current_use() const { return current_use_; }
/// true if the Pool might delay this edge
bool ShouldDelayEdge() const { return depth_ != 0; }
/// informs this Pool that the given edge is committed to be run.
/// Pool will count this edge as using resources from this pool.
void EdgeScheduled(const Edge& edge);
/// informs this Pool that the given edge is no longer runnable, and should
/// relinquish its resources back to the pool
void EdgeFinished(const Edge& edge);
/// adds the given edge to this Pool to be delayed.
void DelayEdge(Edge* edge);
/// Pool will add zero or more edges to the ready_queue
void RetrieveReadyEdges(EdgeSet* ready_queue);
/// Dump the Pool and its edges (useful for debugging).
void Dump() const;
private:
std::string name_;
/// |current_use_| is the total of the weights of the edges which are
/// currently scheduled in the Plan (i.e. the edges in Plan::ready_).
int current_use_;
int depth_;
struct WeightedEdgeCmp {
bool operator()(const Edge* a, const Edge* b) const {
if (!a) return b;
if (!b) return false;
int weight_diff = a->weight() - b->weight();
return ((weight_diff < 0) || (weight_diff == 0 && EdgeCmp()(a, b)));
}
};
typedef std::set<Edge*, WeightedEdgeCmp> DelayedEdges;
DelayedEdges delayed_;
};
/// Global state (file status) for a single run.
struct State {
static Pool kDefaultPool;
static Pool kConsolePool;
static const Rule kPhonyRule;
State();
void AddPool(Pool* pool);
Pool* LookupPool(const std::string& pool_name);
Edge* AddEdge(const Rule* rule);
Node* GetNode(StringPiece path, uint64_t slash_bits);
Node* LookupNode(StringPiece path) const;
Node* SpellcheckNode(const std::string& path);
void AddIn(Edge* edge, StringPiece path, uint64_t slash_bits);
bool AddOut(Edge* edge, StringPiece path, uint64_t slash_bits);
void AddValidation(Edge* edge, StringPiece path, uint64_t slash_bits);
bool AddDefault(StringPiece path, std::string* error);
/// Reset state. Keeps all nodes and edges, but restores them to the
/// state where we haven't yet examined the disk for dirty state.
void Reset();
/// Dump the nodes and Pools (useful for debugging).
void Dump();
/// @return the root node(s) of the graph. (Root nodes have no output edges).
/// @param error where to write the error message if somethings went wrong.
std::vector<Node*> RootNodes(std::string* error) const;
std::vector<Node*> DefaultNodes(std::string* error) const;
/// Mapping of path -> Node.
typedef ExternalStringHashMap<Node*>::Type Paths;
Paths paths_;
/// All the pools used in the graph.
std::map<std::string, Pool*> pools_;
/// All the edges of the graph.
std::vector<Edge*> edges_;
BindingEnv bindings_;
std::vector<Node*> defaults_;
};
#endif // NINJA_STATE_H_
|
