Improve eval benchmark message structure to waste fewer objects (for both…

Improve eval benchmark message structure to waste fewer objects (for both protobuf and capnproto, but this turns out to help capnproto more than protobufs).

c++/src/capnproto/benchmark/benchmark-capnproto.c++

@@ -119,48 +119,68 @@ inline int32_t mod(int32_t a, int32_t b) {
 }
 
 int32_t makeExpression(Expression::Builder exp, int depth) {
+  // TODO:  Operation_MAX or something.
+  exp.setOp((Operation)(rand() % (int)Operation::MODULUS + 1));
+
+  int left, right;
+
   if (rand() % 8 < depth) {
-    exp.setOp(Operation::VALUE);
-    exp.setValue(rand() % 128 + 1);
-    return exp.getValue();
+    exp.setLeftIsValue(true);
+    left = rand() % 128 + 1;
+    exp.setLeftValue(left);
   } else {
-    // TODO:  Operation_MAX or something.
-    exp.setOp((Operation)(rand() % (int)Operation::MODULUS + 1));
-    int32_t left = makeExpression(exp.initLeft(), depth + 1);
-    int32_t right = makeExpression(exp.initRight(), depth + 1);
-    switch (exp.getOp()) {
-      case Operation::ADD:
-        return left + right;
-      case Operation::SUBTRACT:
-        return left - right;
-      case Operation::MULTIPLY:
-        return left * right;
-      case Operation::DIVIDE:
-        return div(left, right);
-      case Operation::MODULUS:
-        return mod(left, right);
-      case Operation::VALUE:
-        break;
-    }
-    throw std::logic_error("Can't get here.");
+    left = makeExpression(exp.initLeftExpression(), depth + 1);
+  }
+
+  if (rand() % 8 < depth) {
+    exp.setRightIsValue(true);
+    right = rand() % 128 + 1;
+    exp.setRightValue(right);
+  } else {
+    right = makeExpression(exp.initRightExpression(), depth + 1);
+  }
+
+  switch (exp.getOp()) {
+    case Operation::ADD:
+      return left + right;
+    case Operation::SUBTRACT:
+      return left - right;
+    case Operation::MULTIPLY:
+      return left * right;
+    case Operation::DIVIDE:
+      return div(left, right);
+    case Operation::MODULUS:
+      return mod(left, right);
   }
+  throw std::logic_error("Can't get here.");
 }
 
 int32_t evaluateExpression(Expression::Reader exp) {
+  int left, right;
+
+  if (exp.getLeftIsValue()) {
+    left = exp.getLeftValue();
+  } else {
+    left = evaluateExpression(exp.getLeftExpression());
+  }
+
+  if (exp.getRightIsValue()) {
+    right = exp.getRightValue();
+  } else {
+    right = evaluateExpression(exp.getRightExpression());
+  }
+
   switch (exp.getOp()) {
-    case Operation::VALUE:
-      return exp.getValue();
     case Operation::ADD:
-      return evaluateExpression(exp.getLeft()) + evaluateExpression(exp.getRight());
+      return left + right;
     case Operation::SUBTRACT:
-      return evaluateExpression(exp.getLeft()) - evaluateExpression(exp.getRight());
+      return left - right;
     case Operation::MULTIPLY:
-      return evaluateExpression(exp.getLeft()) * evaluateExpression(exp.getRight());
+      return left * right;
     case Operation::DIVIDE:
-      return div(evaluateExpression(exp.getLeft()), evaluateExpression(exp.getRight()));
-    case Operation::MODULUS: {
-      return mod(evaluateExpression(exp.getLeft()), evaluateExpression(exp.getRight()));
-    }
+      return div(left, right);
+    case Operation::MODULUS:
+      return mod(left, right);
   }
   throw std::logic_error("Can't get here.");
 }

c++/src/capnproto/benchmark/benchmark-protobuf.c++

@@ -119,47 +119,65 @@ inline int32_t mod(int32_t a, int32_t b) {
 }
 
 int32_t makeExpression(Expression* exp, int depth) {
+  exp->set_op((Operation)(rand() % Operation_MAX + 1));
+
+  int left, right;
+
   if (rand() % 8 < depth) {
-    exp->set_op(Operation::VALUE);
-    exp->set_value(rand() % 128 + 1);
-    return exp->value();
+    left = rand() % 128 + 1;
+    exp->set_left_value(left);
   } else {
-    exp->set_op((Operation)(rand() % Operation_MAX + 1));
-    int32_t left = makeExpression(exp->mutable_left(), depth + 1);
-    int32_t right = makeExpression(exp->mutable_right(), depth + 1);
-    switch (exp->op()) {
-      case Operation::ADD:
-        return left + right;
-      case Operation::SUBTRACT:
-        return left - right;
-      case Operation::MULTIPLY:
-        return left * right;
-      case Operation::DIVIDE:
-        return div(left, right);
-      case Operation::MODULUS:
-        return mod(left, right);
-      case Operation::VALUE:
-        break;
-    }
-    throw std::logic_error("Can't get here.");
+    left = makeExpression(exp->mutable_left_expression(), depth + 1);
+  }
+
+  if (rand() % 8 < depth) {
+    right = rand() % 128 + 1;
+    exp->set_right_value(right);
+  } else {
+    right = makeExpression(exp->mutable_right_expression(), depth + 1);
   }
+
+  switch (exp->op()) {
+    case Operation::ADD:
+      return left + right;
+    case Operation::SUBTRACT:
+      return left - right;
+    case Operation::MULTIPLY:
+      return left * right;
+    case Operation::DIVIDE:
+      return div(left, right);
+    case Operation::MODULUS:
+      return mod(left, right);
+  }
+  throw std::logic_error("Can't get here.");
 }
 
 int32_t evaluateExpression(const Expression& exp) {
+  int left, right;
+
+  if (exp.has_left_value()) {
+    left = exp.left_value();
+  } else {
+    left = evaluateExpression(exp.left_expression());
+  }
+
+  if (exp.has_right_value()) {
+    right = exp.right_value();
+  } else {
+    right = evaluateExpression(exp.right_expression());
+  }
+
   switch (exp.op()) {
-    case Operation::VALUE:
-      return exp.value();
     case Operation::ADD:
-      return evaluateExpression(exp.left()) + evaluateExpression(exp.right());
+      return left + right;
     case Operation::SUBTRACT:
-      return evaluateExpression(exp.left()) - evaluateExpression(exp.right());
+      return left - right;
     case Operation::MULTIPLY:
-      return evaluateExpression(exp.left()) * evaluateExpression(exp.right());
+      return left * right;
     case Operation::DIVIDE:
-      return div(evaluateExpression(exp.left()), evaluateExpression(exp.right()));
-    case Operation::MODULUS: {
-      return mod(evaluateExpression(exp.left()), evaluateExpression(exp.right()));
-    }
+      return div(left, right);
+    case Operation::MODULUS:
+      return mod(left, right);
   }
   throw std::logic_error("Can't get here.");
 }

c++/src/capnproto/benchmark/benchmark.capnp

@@ -22,19 +22,25 @@
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 enum Operation {
-  value = 0;
-  add = 1;
-  subtract = 2;
-  multiply = 3;
-  divide = 4;
-  modulus = 5;
+  add = 0;
+  subtract = 1;
+  multiply = 2;
+  divide = 3;
+  modulus = 4;
 }
 
 struct Expression {
   op@0: Operation;
-  value@1: Int32;
-  left@2: Expression;
-  right@3: Expression;
+
+  # TODO:  Use unions once fully-implemented.
+
+  leftIsValue@1: Bool;
+  leftValue@2: Int32;
+  leftExpression@3: Expression;
+
+  rightIsValue@4: Bool;
+  rightValue@5: Int32;
+  rightExpression@6: Expression;
 }
 
 struct EvaluationResult {

c++/src/capnproto/benchmark/benchmark.proto

@@ -24,19 +24,21 @@
 package capnproto.benchmark.protobuf;
 
 enum Operation {
-  VALUE = 0;
-  ADD = 1;
-  SUBTRACT = 2;
-  MULTIPLY = 3;
-  DIVIDE = 4;
-  MODULUS = 5;
+  ADD = 0;
+  SUBTRACT = 1;
+  MULTIPLY = 2;
+  DIVIDE = 3;
+  MODULUS = 4;
 }
 
 message Expression {
   required Operation op = 1;
-  optional int32 value = 2;
-  optional Expression left = 3;
-  optional Expression right = 4;
+
+  optional int32 left_value = 2;
+  optional Expression left_expression = 3;
+
+  optional int32 right_value = 4;
+  optional Expression right_expression = 5;
 }
 
 message EvaluationResult {