Refactor propagation benchmarks and add b3format benchmarks. (#1390)

3 files changed, 187 insertions, 19 deletions

diff --git a/benchmarks/src/jmh/java/io/opencensus/benchmarks/trace/propagation/B3FormatImplBenchmark.java b/benchmarks/src/jmh/java/io/opencensus/benchmarks/trace/propagation/B3FormatImplBenchmark.java
new file mode 100644
index 00000000..eb20ec2c
--- /dev/null
+++ b/benchmarks/src/jmh/java/io/opencensus/benchmarks/trace/propagation/B3FormatImplBenchmark.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2018, OpenCensus Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.opencensus.benchmarks.trace.propagation;
+
+import io.opencensus.trace.SpanContext;
+import io.opencensus.trace.SpanId;
+import io.opencensus.trace.TraceId;
+import io.opencensus.trace.TraceOptions;
+import io.opencensus.trace.Tracestate;
+import io.opencensus.trace.Tracing;
+import io.opencensus.trace.propagation.SpanContextParseException;
+import io.opencensus.trace.propagation.TextFormat;
+import io.opencensus.trace.propagation.TextFormat.Getter;
+import io.opencensus.trace.propagation.TextFormat.Setter;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+
+/** Benchmarks for {@link io.opencensus.implcore.trace.propagation.B3Format}. */
+@State(Scope.Benchmark)
+public class B3FormatImplBenchmark {
+  @State(Scope.Thread)
+  public static class Data {
+    private TextFormatBenchmarkBase textFormatBase;
+    private SpanContext spanContext;
+    private Map<String, String> spanContextHeaders;
+
+    @Setup
+    public void setup() {
+      textFormatBase = new TextFormatBenchmarkBase(Tracing.getPropagationComponent().getB3Format());
+      Random random = new Random(1234);
+      spanContext =
+          SpanContext.create(
+              TraceId.generateRandomId(random),
+              SpanId.generateRandomId(random),
+              TraceOptions.builder().setIsSampled(random.nextBoolean()).build(),
+              Tracestate.builder().build());
+      spanContextHeaders = new HashMap<String, String>();
+      textFormatBase.inject(spanContext, spanContextHeaders);
+    }
+  }
+
+  /**
+   * This benchmark attempts to measure performance of {@link TextFormat#inject(SpanContext, Object,
+   * Setter)}.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public Map<String, String> inject(Data data) {
+    Map<String, String> carrier = new HashMap<String, String>();
+    data.textFormatBase.inject(data.spanContext, carrier);
+    return carrier;
+  }
+
+  /**
+   * This benchmark attempts to measure performance of {@link TextFormat#extract(Object, Getter)}.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public SpanContext extract(Data data) throws SpanContextParseException {
+    return data.textFormatBase.extract(data.spanContextHeaders);
+  }
+
+  /**
+   * This benchmark attempts to measure performance of {@link TextFormat#inject(SpanContext, Object,
+   * Setter)} then {@link TextFormat#extract(Object, Getter)}.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public SpanContext injectExtract(Data data) throws SpanContextParseException {
+    Map<String, String> carrier = new HashMap<String, String>();
+    data.textFormatBase.inject(data.spanContext, carrier);
+    return data.textFormatBase.extract(carrier);
+  }
+}
diff --git a/benchmarks/src/jmh/java/io/opencensus/benchmarks/trace/propagation/BinaryPropagationImplBenchmark.java b/benchmarks/src/jmh/java/io/opencensus/benchmarks/trace/propagation/BinaryFormatImplBenchmark.java
index b572bbef..391ca906 100644
--- a/benchmarks/src/jmh/java/io/opencensus/benchmarks/trace/propagation/BinaryPropagationImplBenchmark.java
+++ b/benchmarks/src/jmh/java/io/opencensus/benchmarks/trace/propagation/BinaryFormatImplBenchmark.java
@@ -24,29 +24,38 @@ import io.opencensus.trace.Tracestate;
 import io.opencensus.trace.Tracing;
 import io.opencensus.trace.propagation.BinaryFormat;
 import io.opencensus.trace.propagation.SpanContextParseException;
+import java.util.Random;
 import java.util.concurrent.TimeUnit;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
 import org.openjdk.jmh.annotations.Mode;
 import org.openjdk.jmh.annotations.OutputTimeUnit;
 import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
 import org.openjdk.jmh.annotations.State;
 
 /** Benchmarks for {@link BinaryFormat}. */
 @State(Scope.Benchmark)
-public class BinaryPropagationImplBenchmark {
-  private static final byte[] traceIdBytes =
-      new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 'a'};
-  private static final TraceId traceId = TraceId.fromBytes(traceIdBytes);
-  private static final byte[] spanIdBytes = new byte[] {(byte) 0xFF, 0, 0, 0, 0, 0, 0, 0};
-  private static final SpanId spanId = SpanId.fromBytes(spanIdBytes);
-  private static final byte TRACE_OPTIONS_BYTE = 1;
-  private static final TraceOptions traceOptions = TraceOptions.fromByte(TRACE_OPTIONS_BYTE);
-  private static final SpanContext spanContext =
-      SpanContext.create(traceId, spanId, traceOptions, Tracestate.builder().build());
-  private static final BinaryFormat binaryFormat =
-      Tracing.getPropagationComponent().getBinaryFormat();
-  private static final byte[] spanContextBinary = binaryFormat.toByteArray(spanContext);
+public class BinaryFormatImplBenchmark {
+  @State(Scope.Thread)
+  public static class Data {
+    private BinaryFormat binaryFormat;
+    private SpanContext spanContext;
+    private byte[] spanContextBinary;
+
+    @Setup
+    public void setup() {
+      binaryFormat = Tracing.getPropagationComponent().getBinaryFormat();
+      Random random = new Random(1234);
+      spanContext =
+          SpanContext.create(
+              TraceId.generateRandomId(random),
+              SpanId.generateRandomId(random),
+              TraceOptions.builder().setIsSampled(random.nextBoolean()).build(),
+              Tracestate.builder().build());
+      spanContextBinary = binaryFormat.toByteArray(spanContext);
+    }
+  }
 
   /**
    * This benchmark attempts to measure performance of {@link
@@ -55,8 +64,8 @@ public class BinaryPropagationImplBenchmark {
   @Benchmark
   @BenchmarkMode(Mode.SampleTime)
   @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public byte[] toBinarySpanContext() {
-    return binaryFormat.toByteArray(spanContext);
+  public byte[] toBinarySpanContext(Data data) {
+    return data.binaryFormat.toByteArray(data.spanContext);
   }
 
   /**
@@ -65,8 +74,8 @@ public class BinaryPropagationImplBenchmark {
   @Benchmark
   @BenchmarkMode(Mode.SampleTime)
   @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public SpanContext fromBinarySpanContext() throws SpanContextParseException {
-    return binaryFormat.fromByteArray(spanContextBinary);
+  public SpanContext fromBinarySpanContext(Data data) throws SpanContextParseException {
+    return data.binaryFormat.fromByteArray(data.spanContextBinary);
   }
 
   /**
@@ -76,7 +85,7 @@ public class BinaryPropagationImplBenchmark {
   @Benchmark
   @BenchmarkMode(Mode.SampleTime)
   @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public SpanContext toFromBinarySpanContext() throws SpanContextParseException {
-    return binaryFormat.fromByteArray(binaryFormat.toByteArray(spanContext));
+  public SpanContext toFromBinarySpanContext(Data data) throws SpanContextParseException {
+    return data.binaryFormat.fromByteArray(data.binaryFormat.toByteArray(data.spanContext));
   }
 }
diff --git a/benchmarks/src/jmh/java/io/opencensus/benchmarks/trace/propagation/TextFormatBenchmarkBase.java b/benchmarks/src/jmh/java/io/opencensus/benchmarks/trace/propagation/TextFormatBenchmarkBase.java
new file mode 100644
index 00000000..902b0a3a
--- /dev/null
+++ b/benchmarks/src/jmh/java/io/opencensus/benchmarks/trace/propagation/TextFormatBenchmarkBase.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2018, OpenCensus Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.opencensus.benchmarks.trace.propagation;
+
+import io.opencensus.trace.SpanContext;
+import io.opencensus.trace.propagation.SpanContextParseException;
+import io.opencensus.trace.propagation.TextFormat;
+import io.opencensus.trace.propagation.TextFormat.Getter;
+import io.opencensus.trace.propagation.TextFormat.Setter;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+/** Generic benchmarks for {@link io.opencensus.trace.propagation.TextFormat}. */
+final class TextFormatBenchmarkBase {
+  private static final Setter<Map<String, String>> setter =
+      new Setter<Map<String, String>>() {
+        @Override
+        public void put(Map<String, String> carrier, String key, String value) {
+          carrier.put(key, value);
+        }
+      };
+
+  private static final Getter<Map<String, String>> getter =
+      new Getter<Map<String, String>>() {
+        @Nullable
+        @Override
+        public String get(Map<String, String> carrier, String key) {
+          return carrier.get(key);
+        }
+      };
+
+  private final TextFormat textFormat;
+
+  TextFormatBenchmarkBase(TextFormat textFormat) {
+    this.textFormat = textFormat;
+  }
+
+  void inject(SpanContext spanContext, Map<String, String> carrier) {
+    textFormat.inject(spanContext, carrier, setter);
+  }
+
+  SpanContext extract(Map<String, String> carrier) throws SpanContextParseException {
+    return textFormat.extract(carrier, getter);
+  }
+}