Add SerializeNull and SerializeSmi benchmark for benchmarking serialization of the messages used in…

runtime/vm/benchmark_test.cc

Index: runtime/vm/benchmark_test.cc
diff --git a/runtime/vm/benchmark_test.cc b/runtime/vm/benchmark_test.cc
index 94d8baf011a7e821c580c5f42308ca2693ff197f..d8d691b3f860cd14007ec777905e24db97118d84 100644
--- a/runtime/vm/benchmark_test.cc
+++ b/runtime/vm/benchmark_test.cc
@@ -502,4 +502,52 @@ BENCHMARK(EnterExitIsolate) {
   benchmark->set_score(elapsed_time);
 }
 
+
+BENCHMARK(SerializeNull) {
+  const Object& null_object = Object::Handle();
+  const intptr_t kLoopCount = 1000000;
+  Isolate* isolate = Isolate::Current();
+  uint8_t* buffer;
+  Timer timer(true, "Serialize Null");
+  timer.Start();
+  for (intptr_t i = 0; i < kLoopCount; i++) {
+    MessageWriter writer(&buffer, &malloc_allocator);
+    writer.WriteMessage(null_object);
+    intptr_t buffer_len = writer.BytesWritten();
+
+    // Read object back from the snapshot.
+    SnapshotReader reader(buffer, buffer_len,
+                          Snapshot::kMessage, isolate);
+    reader.ReadObject();
+    free(buffer);
+  }
+  timer.Stop();
+  int64_t elapsed_time = timer.TotalElapsedTime();
+  benchmark->set_score(elapsed_time);
+}
+
+
+BENCHMARK(SerializeSmi) {
+  const Integer& smi_object = Integer::Handle(Smi::New(42));
+  const intptr_t kLoopCount = 1000000;
+  Isolate* isolate = Isolate::Current();
+  uint8_t* buffer;
+  Timer timer(true, "Serialize Smi");
+  timer.Start();
+  for (intptr_t i = 0; i < kLoopCount; i++) {
+    MessageWriter writer(&buffer, &malloc_allocator);

[siva, 2014/02/11 23:50:41]

sing malloc_allocator here means that you are measuring the cost
of malloc/free in this loop.

Changing this allocator to message_allocator and getting rid
of the free in the loop cuts SerializeSmi from
513644 micorseconds to 356110 microseconds

static uint8_t message_buffer[64];
static uint8_t* message_allocator(
    uint8_t* ptr, intptr_t old_size, intptr_t new_size) {
  return message_buffer;
}

[Anders Johnsen, 2014/02/12 07:23:26]

This was actually on purpose. I'm trying to understand where all the time goes,
and measuring without the allocation, it's not really measuring what we do in
the the MessageHandler.

On the other hand, if we do want to speed up the serialization part of this, it
may be easier to not include the allocation.

[siva, 2014/02/12 19:29:23]

I agree that you want to measure what goes on in the MessageHandler and that is
why I find this benchmark a bit misleading.

From this benchmark we would tend to infer that it takes 500 ns to
serialize/deserialize a Smi which is not quite right. If all we are interested
in is measuring the cost of serializing/deserializing Smi we should create a
SnapshotWriter write about 10000 smis and read back the 10000 Smis and measure
the cost for each Smi.

You should probably add a different benchmark SimpleMessage or something like
that which does a loop of creating a typical message (maybe more than just a Smi
or Null) and reading it back.

On 2014/02/12 07:23:26, Anders Johnsen wrote:

[Anders Johnsen, 2014/03/18 19:26:48]

Done.

+    writer.WriteMessage(smi_object);
+    intptr_t buffer_len = writer.BytesWritten();
+
+    // Read object back from the snapshot.
+    SnapshotReader reader(buffer, buffer_len,
+                          Snapshot::kMessage, isolate);
+    reader.ReadObject();
+    free(buffer);
+  }
+  timer.Stop();
+  int64_t elapsed_time = timer.TotalElapsedTime();
+  benchmark->set_score(elapsed_time);
+}
+
 }  // namespace dart