}
}
-void Plan::EdgeFinished(Edge* edge) {
+void Plan::EdgeFinished(Edge* edge, bool success) {
map<Edge*, bool>::iterator e = want_.find(edge);
assert(e != want_.end());
bool directly_wanted = e->second;
- if (directly_wanted)
- --wanted_edges_;
- want_.erase(e);
- edge->outputs_ready_ = true;
// See if this job frees up any delayed jobs.
if (directly_wanted)
edge->pool()->EdgeFinished(*edge);
edge->pool()->RetrieveReadyEdges(&ready_);
+ // The rest of this function only applies to successful commands.
+ if (!success)
+ return;
+
+ if (directly_wanted)
+ --wanted_edges_;
+ want_.erase(e);
+ edge->outputs_ready_ = true;
+
// Check off any nodes we were waiting for with this edge.
for (vector<Node*>::iterator o = edge->outputs_.begin();
o != edge->outputs_.end(); ++o) {
} else {
// We do not need to build this edge, but we might need to build one of
// its dependents.
- EdgeFinished(*oe);
+ EdgeFinished(*oe, true);
}
}
}
}
if (edge->is_phony()) {
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
} else {
++pending_commands;
}
&start_time, &end_time);
// The rest of this function only applies to successful commands.
- if (!result->success())
+ if (!result->success()) {
+ plan_.EdgeFinished(edge, false);
return true;
+ }
// Restat the edge outputs, if necessary.
TimeStamp restat_mtime = 0;
}
}
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
// Delete any left over response file.
string rspfile = edge->GetUnescapedRspfile();
ASSERT_FALSE(plan_.FindWork());
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
edge = plan_.FindWork();
ASSERT_TRUE(edge);
ASSERT_EQ("mid", edge->inputs_[0]->path());
ASSERT_EQ("out", edge->outputs_[0]->path());
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
ASSERT_FALSE(plan_.more_to_do());
edge = plan_.FindWork();
Edge* edge;
edge = plan_.FindWork();
ASSERT_TRUE(edge); // cat in
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
edge = plan_.FindWork();
ASSERT_TRUE(edge); // cat mid1 mid2
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
edge = plan_.FindWork();
ASSERT_FALSE(edge); // done
Edge* edge;
edge = plan_.FindWork();
ASSERT_TRUE(edge); // cat in
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
edge = plan_.FindWork();
ASSERT_TRUE(edge); // cat a1
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
edge = plan_.FindWork();
ASSERT_TRUE(edge); // cat a2
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
edge = plan_.FindWork();
ASSERT_TRUE(edge); // cat b1 b2
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
edge = plan_.FindWork();
ASSERT_FALSE(edge); // done
Edge* edge;
edge = plan_.FindWork();
ASSERT_TRUE(edge); // cat in
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
edge = plan_.FindWork();
ASSERT_TRUE(edge); // cat mid
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
edge = plan_.FindWork();
ASSERT_TRUE(edge); // cat mid
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
edge = plan_.FindWork();
ASSERT_TRUE(edge); // cat a1 a2
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
edge = plan_.FindWork();
ASSERT_FALSE(edge); // done
// This will be false since poolcat is serialized
ASSERT_FALSE(plan_.FindWork());
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
edge = plan_.FindWork();
ASSERT_TRUE(edge);
ASSERT_FALSE(plan_.FindWork());
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
ASSERT_FALSE(plan_.more_to_do());
edge = plan_.FindWork();
ASSERT_EQ("outb3", edge->outputs_[0]->path());
// finish out1
- plan_.EdgeFinished(edges.front());
+ plan_.EdgeFinished(edges.front(), true);
edges.pop_front();
// out3 should be available
ASSERT_FALSE(plan_.FindWork());
- plan_.EdgeFinished(out3);
+ plan_.EdgeFinished(out3, true);
ASSERT_FALSE(plan_.FindWork());
for (deque<Edge*>::iterator it = edges.begin(); it != edges.end(); ++it) {
- plan_.EdgeFinished(*it);
+ plan_.EdgeFinished(*it, true);
}
Edge* last = plan_.FindWork();
ASSERT_TRUE(last);
ASSERT_EQ("allTheThings", last->outputs_[0]->path());
- plan_.EdgeFinished(last);
+ plan_.EdgeFinished(last, true);
ASSERT_FALSE(plan_.more_to_do());
ASSERT_FALSE(plan_.FindWork());
edge = initial_edges[1]; // Foo first
ASSERT_EQ("foo.cpp", edge->outputs_[0]->path());
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
edge = plan_.FindWork();
ASSERT_TRUE(edge);
ASSERT_EQ("foo.cpp", edge->inputs_[0]->path());
ASSERT_EQ("foo.cpp", edge->inputs_[1]->path());
ASSERT_EQ("foo.cpp.obj", edge->outputs_[0]->path());
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
edge = initial_edges[0]; // Now for bar
ASSERT_EQ("bar.cpp", edge->outputs_[0]->path());
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
edge = plan_.FindWork();
ASSERT_TRUE(edge);
ASSERT_EQ("bar.cpp", edge->inputs_[0]->path());
ASSERT_EQ("bar.cpp", edge->inputs_[1]->path());
ASSERT_EQ("bar.cpp.obj", edge->outputs_[0]->path());
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
edge = plan_.FindWork();
ASSERT_TRUE(edge);
ASSERT_EQ("foo.cpp.obj", edge->inputs_[0]->path());
ASSERT_EQ("bar.cpp.obj", edge->inputs_[1]->path());
ASSERT_EQ("libfoo.a", edge->outputs_[0]->path());
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
edge = plan_.FindWork();
ASSERT_TRUE(edge);
ASSERT_FALSE(plan_.FindWork());
ASSERT_EQ("libfoo.a", edge->inputs_[0]->path());
ASSERT_EQ("all", edge->outputs_[0]->path());
- plan_.EdgeFinished(edge);
+ plan_.EdgeFinished(edge, true);
edge = plan_.FindWork();
ASSERT_FALSE(edge);
ASSERT_FALSE(plan_.more_to_do());
}
+TEST_F(PlanTest, PoolWithFailingEdge) {
+ ASSERT_NO_FATAL_FAILURE(AssertParse(&state_,
+ "pool foobar\n"
+ " depth = 1\n"
+ "rule poolcat\n"
+ " command = cat $in > $out\n"
+ " pool = foobar\n"
+ "build out1: poolcat in\n"
+ "build out2: poolcat in\n"));
+ GetNode("out1")->MarkDirty();
+ GetNode("out2")->MarkDirty();
+ string err;
+ EXPECT_TRUE(plan_.AddTarget(GetNode("out1"), &err));
+ ASSERT_EQ("", err);
+ EXPECT_TRUE(plan_.AddTarget(GetNode("out2"), &err));
+ ASSERT_EQ("", err);
+ ASSERT_TRUE(plan_.more_to_do());
+
+ Edge* edge = plan_.FindWork();
+ ASSERT_TRUE(edge);
+ ASSERT_EQ("in", edge->inputs_[0]->path());
+ ASSERT_EQ("out1", edge->outputs_[0]->path());
+
+ // This will be false since poolcat is serialized
+ ASSERT_FALSE(plan_.FindWork());
+
+ plan_.EdgeFinished(edge, false);
+
+ edge = plan_.FindWork();
+ ASSERT_TRUE(edge);
+ ASSERT_EQ("in", edge->inputs_[0]->path());
+ ASSERT_EQ("out2", edge->outputs_[0]->path());
+
+ ASSERT_FALSE(plan_.FindWork());
+
+ plan_.EdgeFinished(edge, false);
+
+ ASSERT_TRUE(plan_.more_to_do()); // Jobs have failed
+ edge = plan_.FindWork();
+ ASSERT_EQ(0, edge);
+}
+
/// Fake implementation of CommandRunner, useful for tests.
struct FakeCommandRunner : public CommandRunner {
explicit FakeCommandRunner(VirtualFileSystem* fs) :