Permalink
Browse files

add a class for logging builds (commands + timing)

  • Loading branch information...
1 parent 12e3628 commit 9a6fd1a97b64ea1245a7343aee1e584c401a391b @evmar evmar committed Dec 16, 2010
Showing with 179 additions and 5 deletions.
  1. +8 −4 build.ninja
  2. +89 −0 src/build_log.cc
  3. +37 −0 src/build_log.h
  4. +43 −0 src/build_log_test.cc
  5. +2 −1 todo
View
12 build.ninja
@@ -29,22 +29,26 @@ rule link
# build "ninja.a" by linking the builddir's "ninja.o",
# and build that "ninja.o" by compiling "ninja.cc".
build $builddir/build.o: cxx src/build.cc
+build $builddir/build_log.o: cxx src/build_log.cc
build $builddir/parsers.o: cxx src/parsers.cc
build $builddir/subprocess.o: cxx src/subprocess.cc
build $builddir/util.o: cxx src/util.cc
build $builddir/ninja_jumble.o: cxx src/ninja_jumble.cc
-build $builddir/ninja.a: ar $builddir/build.o $builddir/parsers.o \
- $builddir/subprocess.o $builddir/util.o $builddir/ninja_jumble.o
+build $builddir/ninja.a: ar $builddir/build.o $builddir/build_log.o \
+ $builddir/parsers.o $builddir/subprocess.o $builddir/util.o \
+ $builddir/ninja_jumble.o
build $builddir/ninja.o: cxx src/ninja.cc
build ninja: link $builddir/ninja.o $builddir/ninja.a
build $builddir/build_test.o: cxx src/build_test.cc
+build $builddir/build_log_test.o: cxx src/build_log_test.cc
build $builddir/ninja_test.o: cxx src/ninja_test.cc
build $builddir/parsers_test.o: cxx src/parsers_test.cc
build $builddir/subprocess_test.o: cxx src/subprocess_test.cc
-build ninja_test: link $builddir/build_test.o $builddir/ninja_test.o \
- $builddir/parsers_test.o $builddir/subprocess_test.o $builddir/ninja.a
+build ninja_test: link $builddir/build_test.o $builddir/build_log_test.o \
+ $builddir/ninja_test.o $builddir/parsers_test.o \
+ $builddir/subprocess_test.o $builddir/ninja.a
ldflags = -g -rdynamic -lgtest -lgtest_main -lpthread
View
89 src/build_log.cc
@@ -0,0 +1,89 @@
+#include "build_log.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "ninja.h"
+
+// Implementation details:
+// Each run's log appends to the log file.
+// To load, we run through all log entries in series, throwing away
+// older runs.
+// XXX figure out recompaction strategy
+
+bool BuildLog::OpenForWrite(const string& path, string* err) {
+ log_file_ = fopen(path.c_str(), "ab");
+ if (!log_file_) {
+ *err = strerror(errno);
+ return false;
+ }
+ setlinebuf(log_file_);
+ return true;
+}
+
+void BuildLog::RecordCommand(Edge* edge, int time_ms) {
+ const string command = edge->EvaluateCommand();
+ for (vector<Node*>::iterator out = edge->outputs_.begin();
+ out != edge->outputs_.end(); ++out) {
+ const string& path = (*out)->file_->path_;
+ Log::iterator i = log_.find(path);
+ LogEntry* log_entry;
+ if (i != log_.end()) {
+ log_entry = i->second;
+ } else {
+ log_entry = new LogEntry;
+ log_.insert(make_pair(path, log_entry));
+ }
+ log_entry->output = path;
+ log_entry->command = command;
+ log_entry->time_ms = time_ms;
+
+ fprintf(log_file_, "%d %s %s\n", time_ms, path.c_str(), command.c_str());
+ }
+}
+
+void BuildLog::Close() {
+ fclose(log_file_);
+ log_file_ = NULL;
+}
+
+// Load the on-disk log.
+bool BuildLog::Load(const string& path, string* err) {
+ FILE* file = fopen(path.c_str(), "r");
+ if (!file) {
+ *err = strerror(errno);
+ return false;
+ }
+
+ char buf[4 << 10];
+ while (fgets(buf, sizeof(buf), file)) {
+ char* start = buf;
+ char* end = strchr(start, ' ');
+ if (!end)
+ continue;
+
+ LogEntry* entry = new LogEntry;
+ *end = 0;
+ entry->time_ms = atoi(start);
+
+ start = end + 1;
+ end = strchr(start, ' ');
+ entry->output = string(start, end - start);
+
+ start = end + 1;
+ end = strchr(start, '\n');
+ entry->command = string(start, end - start);
+ log_.insert(make_pair(entry->output, entry));
+ }
+
+ return true;
+}
+
+// Lookup a previously-run command by its output path.
+BuildLog::LogEntry* BuildLog::LookupByOutput(const string& path) {
+ Log::iterator i = log_.find(path);
+ if (i != log_.end())
+ return i->second;
+ return NULL;
+}
View
37 src/build_log.h
@@ -0,0 +1,37 @@
+#include <map>
+#include <string>
+using namespace std;
+
+struct Edge;
+
+// Store a log of every command ran for every build.
+// It has a few uses:
+// 1) historical command lines for output files, so we know
+// when we need to rebuild due to the command changing
+// 2) historical timing information
+// 3) maybe we can generate some sort of build overview output
+// from it
+struct BuildLog {
+ bool OpenForWrite(const string& path, string* err);
+ void RecordCommand(Edge* edge, int time_ms);
+ void Close();
+
+ // Load the on-disk log.
+ bool Load(const string& path, string* err);
+
+ struct LogEntry {
+ string output;
+ string command;
+ int time_ms;
+ bool operator==(const LogEntry& o) {
+ return output == o.output && command == o.command && time_ms == o.time_ms;
+ }
+ };
+
+ // Lookup a previously-run command by its output path.
+ LogEntry* LookupByOutput(const string& path);
+
+ typedef map<string, LogEntry*> Log;
+ Log log_;
+ FILE* log_file_;
+};
View
43 src/build_log_test.cc
@@ -0,0 +1,43 @@
+#include "build_log.h"
+
+#include "test.h"
+
+struct BuildLogTest : public StateTestWithBuiltinRules {
+ virtual void SetUp() {
+ char mktemp_template[] = "BuildLogTest-XXXXXX";
+ log_filename_ = mktemp(mktemp_template);
+ }
+ virtual void TearDown() {
+ unlink(log_filename_.c_str());
+ }
+
+ string log_filename_;
+};
+
+TEST_F(BuildLogTest, WriteRead) {
+ AssertParse(&state_,
+"build out: cat mid\n"
+"build mid: cat in\n");
+
+ BuildLog log1;
+ string err;
+ EXPECT_TRUE(log1.OpenForWrite(log_filename_, &err));
+ ASSERT_EQ("", err);
+ log1.RecordCommand(state_.edges_[0], 15);
+ log1.RecordCommand(state_.edges_[1], 20);
+ log1.Close();
+
+ BuildLog log2;
+ EXPECT_TRUE(log2.Load(log_filename_, &err));
+ ASSERT_EQ("", err);
+
+ ASSERT_EQ(2, log1.log_.size());
+ ASSERT_EQ(2, log2.log_.size());
+ BuildLog::LogEntry* e1 = log1.LookupByOutput("out");
+ ASSERT_TRUE(e1);
+ BuildLog::LogEntry* e2 = log2.LookupByOutput("out");
+ ASSERT_TRUE(e2);
+ ASSERT_TRUE(*e1 == *e2);
+ ASSERT_EQ(15, e1->time_ms);
+ ASSERT_EQ("out", e1->output);
+}
View
3 todo
@@ -1,5 +1,6 @@
save command lines
- or use mtimes on build files?
+collect per-command timing, perhaps saving with command lines
+
"explain" mode that shows why we're building a file
"one file" mode that builds only outputs of a single file
adjust to system load dynamically

0 comments on commit 9a6fd1a

Please sign in to comment.