Eigen::ThreadPoolDevice device(&pool, pool.NumThreads());

  CPP_CLASS computation;
  computation.set_thread_pool(&device);

  benchmark::Options options;
  benchmark::Stats stats;
  benchmark::Benchmark(options, [&] { computation.Run(); }, &stats);
  benchmark::DumpStatsToStdout(stats);
  return 0;
}

}  // namespace tfcompile
}  // namespace tensorflow

int main(int argc, char** argv) {

{"Action":"output","Test":"BenchmarkFoo-8","Output":"\tx_test.go:8: My benchmark\n"}
{"Action":"output","Test":"BenchmarkFoo-8","Output":"\tx_test.go:8: My benchmark\n"}
{"Action":"output","Test":"BenchmarkFoo-8","Output":"\tx_test.go:8: My benchmark\n"}
{"Action":"output","Test":"BenchmarkFoo-8","Output":"\tx_test.go:8: My benchmark\n"}
{"Action":"output","Test":"BenchmarkFoo-8","Output":"\tx_test.go:8: My benchmark\n"}

        FileUtils.forceDelete(tempDirFile);
    }

    @Benchmark
    public void createFileJava6(Blackhole blackhole) throws IOException {
        File file = new File(tempDirFile, "file-" + counter.incrementAndGet());
        boolean created = file.createNewFile();
        blackhole.consume(created);
    }

    @Benchmark
    public void createFileJava7(Blackhole blackhole) throws IOException {

import com.google.caliper.Benchmark;
import com.google.caliper.Param;
import java.util.List;

/**
 * Benchmark for various ways to create an {@code ImmutableList}.
 *
 * @author Louis Wasserman
 */
public class ImmutableListCreationBenchmark {

  @Param({"10", "1000", "1000000"})
  int size;

  private static final Object OBJECT = new Object();

  @Benchmark
  int builderAdd(int reps) {

  void BM_ScalarSummary##name##device(::testing::benchmark::State& state) { \
    TensorShape tensorshape(DIMARGS dims);                                  \
    auto g = BM_ScalarSummaryOp(tensorshape, #tag, value);                  \
    test::Benchmark("cpu", g, /*old_benchmark_api=*/false).Run(state);      \
  }                                                                         \
  BENCHMARK(BM_ScalarSummary##name##device);

// pointer.
void CallFunctionsBase(::testing::benchmark::State& state) {
  int64_t sum = 0;
  typedef int64_t (*Func)(int64_t a, int64_t b);
  volatile Func f_raw = AddRaw;
  Func f = f_raw;
  size_t i = 0;
  for (auto dummy : state) {
    sum = f(sum, i);
    i++;
  }
  // volatile int64_t result = sum;
}

BENCHMARK(CallFunctions)->Arg(1 << 10);
BENCHMARK(CallFunctionsIndirect)->Arg(1 << 10);

	if err != nil {
		b.Fatal(err)
	}

	// benchmark utility which helps obtain number of allocations and bytes allocated per ops.
	b.ReportAllocs()
	// the actual benchmark for PutObject starts here. Reset the benchmark timer.
	b.ResetTimer()

	if err := req.ParseForm(); err != nil {
		b.Fatal(err)
	}

	b.RunParallel(func(pb *testing.PB) {

		}
	})
}

func TestRunParallelFail(t *testing.T) {
	testing.Benchmark(func(b *testing.B) {
		b.RunParallel(func(pb *testing.PB) {
			// The function must be able to log/abort
			// w/o crashing/deadlocking the whole benchmark.
			b.Log("log")
			b.Error("error")
		})
	})
}

func TestRunParallelFatal(t *testing.T) {
	testing.Benchmark(func(b *testing.B) {
		b.RunParallel(func(pb *testing.PB) {

  }

  @Benchmark
  int hashString_4(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      dummy += Objects.hashCode(S0, S1, S2, S3);
    }
    return dummy;
  }

  @Benchmark
  int hashString_5(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      dummy += Objects.hashCode(S0, S1, S2, S3, S4);
    }
    return dummy;
  }

  @Benchmark

      arrayList.add(value);
      linkedList.add(value);
    }
  }

  @Benchmark
  int arrayIndexed(int reps) {
    int sum = 0;
    for (int i = 0; i < reps; i++) {
      for (int index = 0; index < size; index++) {
        sum += array[index].hashCode();
      }
    }
    return sum;
  }

  @Benchmark
  int arrayIndexedLength(int reps) {
    int sum = 0;
    for (int i = 0; i < reps; i++) {