com.google.caliper.Benchmark Java Examples

@Benchmark
void maybeGet(int n) {
  IOException exception = new IOException();
  for (int i = 0; i < n; i++) {
    try {
      Maybe.except(exception).orElseThrow();
      throw new AssertionError();
    } catch (IOException expected) {}
  }
}
 

@Benchmark
public void invalidateEntries() {
  leaves.forEach(
      leaf ->
          cache.onFileSystemChange(
              WatchmanPathEvent.of(
                  AbsPath.of(projectFilesystem.resolve(leaf)),
                  Kind.CREATE,
                  RelPath.of(Paths.get(leaf)))));
}
 

@Benchmark
private void benchArtifactStore() {
  for (int i = 0; i < contentInfo.size() / 2; i++) {
    artifactCache.store(contentInfo.get(i), BorrowablePath.notBorrowablePath(inlinedFile));
  }

  for (int i = contentInfo.size() / 2; i < contentInfo.size(); i++) {
    artifactCache.store(contentInfo.get(i), BorrowablePath.notBorrowablePath(largeFile));
  }
}
 

@Benchmark
public void parseMultipleTargets() throws Exception {
  parser.buildTargetGraphWithTopLevelConfigurationTargets(
      ParsingContext.builder(cell.getRootCell(), executorService)
          .setSpeculativeParsing(SpeculativeParsing.ENABLED)
          .build(),
      ImmutableList.of(
          TargetNodePredicateSpec.of(
              BuildFileSpec.fromRecursivePath(
                  CellRelativePath.of(
                      cell.getRootCell().getCanonicalName(), ForwardRelativePath.of(""))))),
      Optional.empty());
}
 

@Benchmark
void profiledManually(int reps) {
  for (int i = 0; i < reps; i++) {
    long startTime = Profiler.nanoTimeMaybe();
    Profiler.instance().logSimpleTask(startTime, profilerTaskType, "description");
  }
}
 

@Benchmark
@SuppressWarnings("unused")
void deleteFields(int count)
{
    Function create = (Function)ScriptableObject.getProperty(scope, "createObject");
    Object o = create.call(cx, scope, null, new Object[]{1, strings, ints});
    Function delete = (Function)ScriptableObject.getProperty(scope, "deleteObject");
    delete.call(cx, scope, null, new Object[] {count, o, strings, ints});
}
 

@Benchmark
@SuppressWarnings("unused")
void ownKeysFields(long count)
{
    Function create = (Function)ScriptableObject.getProperty(scope, "createObject");
    Object o = create.call(cx, scope, null, new Object[]{1, strings, ints});
    Function iterate = (Function)ScriptableObject.getProperty(scope, "iterateOwnKeysObject");
    iterate.call(cx, scope, null, new Object[] {count, o});
}
 

@Benchmark
@SuppressWarnings("unused")
void iterateFields(long count)
{
    Function create = (Function)ScriptableObject.getProperty(scope, "createObject");
    Object o = create.call(cx, scope, null, new Object[]{1, strings, ints});
    Function iterate = (Function)ScriptableObject.getProperty(scope, "iterateObject");
    iterate.call(cx, scope, null, new Object[] {count, o});
}
 

@Benchmark
@SuppressWarnings("unused")
void accessFields(int count)
{
    Function create = (Function)ScriptableObject.getProperty(scope, "createObject");
    Object o = create.call(cx, scope, null, new Object[]{1, strings, ints});
    Function access = (Function)ScriptableObject.getProperty(scope, "accessObject");
    access.call(cx, scope, null, new Object[] {count, o, strings, ints});
}
 

@Benchmark
@SuppressWarnings("unused")
void createFields(int count)
{
    Function create = (Function)ScriptableObject.getProperty(scope, "createObject");
    create.call(cx, scope, null, new Object[]{count, strings, ints});
}
 

@Benchmark
void noWrapper(int n) {
  IOException exception = new IOException();
  for (int i = 0; i < n; i++) {
    try {
      Maybe.except(exception).orElseThrow(e -> e);
      throw new AssertionError();
    } catch (IOException expected) {}
  }
}
 

@Benchmark
void manualWrapper(int n) {
  IOException exception = new IOException();
  for (int i = 0; i < n; i++) {
    try {
      Maybe.except(exception).orElseThrow(IOException::new);
      throw new AssertionError();
    } catch (IOException expected) {}
  }
}
 

@Benchmark
void reserializeString(int n) {
  String string = new String("abc");
  for (int i = 0; i < n; i++) {
    SerializableTester.reserialize(string);
  }
}
 

@Benchmark
void reserializeException(int n) {
  IOException exception = new IOException();
  for (int i = 0; i < n; i++) {
    SerializableTester.reserialize(exception);
  }
}
 

@Benchmark
void futuresGetChecked(int n) {
  IOException exception = new IOException();
  CompletableFuture<?> future = new CompletableFuture<>();
  future.completeExceptionally(exception);
  for (int i = 0; i < n; i++) {
    try {
      Futures.getChecked(future, IOException.class);
      throw new AssertionError();
    } catch (IOException expected) {}
  }
}
 

@Benchmark
public void jackson_InputSmall() throws Exception {
    new JacksonSmallXmlBenchmark().parse(xmlSmall);
}
 

@Benchmark
public void tikxml_InputSmall() throws Exception {
    new TikXmlSmallXmlBenchmark().parse(xmlSmall);
}
 

@Benchmark
public void simpleframework_InputSmall() throws Exception {
    new SimpleFrameworkSmallXmlBenchmark().parse(xmlSmall);
}
 

@Benchmark
void profiledWithAutoProfiler(int reps) {
  for (int i = 0; i < reps; i++) {
    try (AutoProfiler p = AutoProfiler.profiled("profiling", profilerTaskType)) {}
  }
}
 

public CaliperRunner(Class<? extends Benchmark> benchmark) {
  this.benchmark = benchmark;
  this.resultsFile = getResultsFile();
}
 

@Benchmark
private void benchMetadataStore() {
  for (ArtifactInfo info : metadataInfo) {
    artifactCache.store(info, BorrowablePath.notBorrowablePath(emptyFile));
  }
}
 

@Benchmark
private void benchMetadataFetch() {
  for (RuleKey key : ruleKeys) {
    Futures.getUnchecked(artifactCache.fetchAsync(null, key, output));
  }
}
 

@Benchmark
private void benchArtifactFetch() {
  for (RuleKey key : ruleKeys) {
    Futures.getUnchecked(artifactCache.fetchAsync(null, key, output));
  }
}
 

@Benchmark
public void addMultipleEntries() {
  addEntries();
}