Add bench_record.

tools/bench_record.cpp

Index: tools/bench_record.cpp
diff --git a/tools/bench_record.cpp b/tools/bench_record.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..219a6b9383cc1290a037a84b6577251cdf8815c8
--- /dev/null
+++ b/tools/bench_record.cpp
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkCommandLineFlags.h"
+#include "SkForceLinking.h"
+#include "SkGraphics.h"
+#include "SkOSFile.h"
+#include "SkPicture.h"
+#include "SkStream.h"
+#include "SkString.h"
+#include "SkTime.h"
+
+__SK_FORCE_IMAGE_DECODER_LINKING;
+
+// Just reading all the SKPs takes about 2 seconds for me, which is the same as about 100 loops of
+// rerecording all the SKPs.  So we default to --loops=900, which makes ~90% of our time spent in
+// recording, and this should take ~20 seconds to run.

[tomhudson, 2014/01/13 11:55:27]

How wildly different will this be on different platforms?

I guess the point here is to let perf capture data not dominated by loading
costs, the way it is on other benchmarks? Since it looks like your timing is
only around the rerecording, that number ought to be clean.

[mtklein_C, 2014/01/13 13:29:27]

As wildly as CPUs and memory bandwidth vary.  On my laptop it takes ~30s. 
Haven't even tried on a phone yet, but I'd guess it's a couple minutes with
--loops 900.

The idea is entirely to amortize away the time it takes to read the picture so
it stays out of the way in in perf / Instruments.  If you know what you're
looking for in the profile, it should be fine to run with a much lower count,
like --loops 10.

I don't tend to look at the numbers we print out as much more than a sanity
check and a progress indicator, but you're right they don't time reading
pictures.  They should be stable with decreasing precision as --loops decreases.

I actually started with a version that ran the benchmarks in parallel.  This
gives you the same profile much faster, but at the cost of very misleading times
printed out on the screen (these are wall-timers I'm using here, not
CPU-timers).  If it would be useful to get a profile faster (down around 2-3s
IIRC),  then maybe we can add that back in as an option and have it just hide
the output when using more than one thread.

+
+DEFINE_string2(skps, r, "skps", "Directory containing SKPs to read and re-record.");
+DEFINE_int32(loops, 900, "Number of times to re-record each SKP.");
+DEFINE_int32(flags, SkPicture::kUsePathBoundsForClip_RecordingFlag, "RecordingFlags to use.");
+DEFINE_bool(endRecording, true, "If false, don't time SkPicture::endRecording()");

[tomhudson, 2014/01/13 11:55:27]

Why would you ever want to do that? endRecording() time is significant.

[mtklein_C, 2014/01/13 13:29:27]

Conceivably, we could move what's done there to another thread, so
--noendRecording lets you measure the absolute recording critical path.

+
+int tool_main(int argc, char** argv);

[tomhudson, 2014/01/13 11:55:27]

Looks like this is an iOS thing? I don't recall seeing it before in the Skia
style.

[mtklein_C, 2014/01/13 13:29:27]

Yeah, all our tools do it.  We have a little shell on iOS that wraps each of our
tools and calls tool_main to run.  I don't think anyone actually uses it; this
is just to make buildbots happy.

+int tool_main(int argc, char** argv) {
+    SkCommandLineFlags::Parse(argc, argv);
+    SkAutoGraphics autoGraphics;
+
+    SkOSFile::Iter it(FLAGS_skps[0], ".skp");
+    SkString filename;
+    while (it.next(&filename)) {
+        const SkString path = SkOSPath::SkPathJoin(FLAGS_skps[0], filename.c_str());
+
+        SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path.c_str()));
+        if (!stream) {
+            SkDebugf("Could not read %s.\n", path.c_str());
+            continue;
+        }
+        SkAutoTUnref<SkPicture> src(SkPicture::CreateFromStream(stream));
+        if (!src) {
+            SkDebugf("Could not read %s as an SkPicture.\n", path.c_str());
+            continue;
+        }
+
+        const SkMSec start = SkTime::GetMSecs();
+        for (int i = 0; i < FLAGS_loops; i++) {
+            SkPicture dst;
+            src->draw(dst.beginRecording(src->width(), src->height(), FLAGS_flags));
+            if (FLAGS_endRecording) dst.endRecording();
+        }
+
+        const SkMSec elapsed = SkTime::GetMSecs() - start;
+        const double msPerLoop = elapsed / (double)FLAGS_loops;
+        printf("%4.2f\t%s\n", msPerLoop, filename.c_str());
+    }
+
+    return 0;
+}
+
+#if !defined SK_BUILD_FOR_IOS
+int main(int argc, char * const argv[]) {
+    return tool_main(argc, (char**) argv);
+}
+#endif