| /external/tensorflow/tensorflow/core/kernels/ |
| requantization_range_op_test.cc | 70 static void BM_RequantizationRange(int iters, int size) {
73 testing::ItemsProcessed(static_cast<int64>(iters) * size);
74 testing::ItemsProcessed(static_cast<int64>(iters) * size * 4);
82 for (int iter = 0; iter < iters; ++iter) {
87 static void BM_RequantizationRange100(int iters) {
88 BM_RequantizationRange(100, iters);
92 static void BM_RequantizationRange1000(int iters) {
93 BM_RequantizationRange(1000, iters);
97 static void BM_RequantizationRange10000(int iters) {
98 BM_RequantizationRange(10000, iters);
[all...] |
| cast_op_test.cc | 94 static void BM_cpu_float_int64(int iters, int num) {
95 testing::ItemsProcessed(static_cast<int64>(iters) * num);
96 testing::BytesProcessed(static_cast<int64>(iters) * num *
99 test::Benchmark("cpu", Cast<float, int64>(num)).Run(iters);
103 static void BM_gpu_float_int64(int iters, int num) {
104 testing::ItemsProcessed(static_cast<int64>(iters) * num);
105 testing::BytesProcessed(static_cast<int64>(iters) * num *
109 test::Benchmark("gpu", Cast<float, int64>(num)).Run(iters);
112 test::Benchmark("sycl", Cast<float, int64>(num)).Run(iters);
117 static void BM_cpu_bool_float(int iters, int num)
[all...] |
| reduction_ops_test.cc | 85 // into a scalar on a "device". Runs the bench for "iters" times.
87 static void ReduceToScalar(int iters, const string& device,
89 testing::ItemsProcessed(static_cast<int64>(iters) * num_x * num_y);
90 testing::BytesProcessed(static_cast<int64>(iters) * num_x * num_y *
92 test::Benchmark(device, ToScalar<T>(reduce, num_x, num_y)).Run(iters);
95 static void DoRowReduce(int iters, const string& device, const string& reduce,
97 testing::ItemsProcessed(static_cast<int64>(iters) * num_x * num_y);
98 testing::BytesProcessed(static_cast<int64>(iters) * num_x * num_y *
100 test::Benchmark(device, RowReduce(reduce, num_x, num_y)).Run(iters);
103 static void DoColReduce(int iters, const string& device, const string& reduce
[all...] |
| slice_op_test.cc | 39 static void SliceHelper(int iters, int size) {
66 testing::BytesProcessed(static_cast<int64>(iters) * kDim * size * sizeof(T));
68 test::Benchmark("cpu", g).Run(iters);
72 static void BM_SliceFloat(int iters, int dim2) {
73 SliceHelper<float>(iters, dim2);
78 static void BM_SliceBFloat16(int iters, int dim2) {
79 SliceHelper<bfloat16>(iters, dim2);
|
| sendrecv_ops_test.cc | 57 static void BM_Send(int iters) {
59 testing::ItemsProcessed(static_cast<int64>(iters));
61 .Run(iters);
65 static void BM_Recv(int iters) {
67 testing::ItemsProcessed(static_cast<int64>(iters));
69 .Run(iters);
|
| concat_op_test.cc | 41 static void ConcatHelper(int iters, int concat_dimension, int dim2) {
63 testing::BytesProcessed(static_cast<int64>(iters) *
66 test::Benchmark("cpu", g).Run(iters);
70 static void BM_ConcatDim0Float(int iters, int dim2) {
71 ConcatHelper<float>(iters, 0, dim2);
74 static void BM_ConcatDim1Float(int iters, int dim2) {
75 ConcatHelper<float>(iters, 1, dim2);
81 static void BM_ConcatDim1int16(int iters, int dim2) {
82 ConcatHelper<int16>(iters, 1, dim2);
84 static void BM_ConcatDim1bfloat16(int iters, int dim2)
[all...] |
| reverse_op_test.cc | 198 static void RunReverseRowsBenchmark(int iters, int outer_dim, int middle_dim,
202 const int64 num_items = static_cast<int64>(iters) * shape.num_elements();
206 test::Benchmark("cpu", Reverse<T>(shape, 1), &opts).Run(iters);
209 static void BM_ReverseRowsOf1Channel_1T_float(int iters, int outer_dim,
211 RunReverseRowsBenchmark<float>(iters, outer_dim, middle_dim,
220 static void BM_ReverseRowsOf1Channel_1T_uint8(int iters, int outer_dim,
222 RunReverseRowsBenchmark<uint8>(iters, outer_dim, middle_dim,
231 static void BM_ReverseRowsOf1Channel_4T_float(int iters, int outer_dim,
233 RunReverseRowsBenchmark<float>(iters, outer_dim, middle_dim,
242 static void BM_ReverseRowsOf1Channel_4T_uint8(int iters, int outer_dim
[all...] |
| random_op_test.cc | 62 void BM_##DEVICE##_##RNG(int iters, int arg) { \
63 testing::ItemsProcessed(static_cast<int64>(iters) * arg); \
64 test::Benchmark(#DEVICE, RNG(arg)).Run(iters); \
87 void BM_cpu_RandomGamma(int iters, int nsamp, int nalpha) {
88 testing::ItemsProcessed(static_cast<int64>(iters) * nsamp * nalpha);
92 test::Benchmark("cpu", g).Run(iters);
96 void BM_PhiloxRandom(int iters) {
100 testing::ItemsProcessed(static_cast<int64>(iters) * count);
105 for (int i = 0; i < iters; ++i) {
120 void BM_StdMTRandom(int iters) {
[all...] |
| strided_slice_op_test.cc | 41 static void SliceHelper(int iters, int size) {
73 testing::BytesProcessed(static_cast<int64>(iters) * kDim * size * sizeof(T));
75 test::Benchmark("cpu", g).Run(iters);
79 static void BM_SliceFloat(int iters, int dim2) {
80 SliceHelper<float>(iters, dim2);
85 static void BM_SliceComplex64(int iters, int dim2) {
86 SliceHelper<std::complex<float>>(iters, dim2);
91 static void BM_SliceBFloat16(int iters, int dim2) {
92 SliceHelper<bfloat16>(iters, dim2);
97 static void BM_ValidateStridedSliceOp(int iters) {
[all...] |
| variable_ops_test.cc | 31 void ManyManyVariablesHelper(int threads, int variables, int iters) {
54 for (int i = 0; i < iters; ++i) {
61 void BM_ManyManyVariablesManyThreads(int iters, int threads) {
62 ManyManyVariablesHelper(threads, 1000, iters);
|
| scatter_op_test.cc | 240 static void BM_ScatterHelper(int iters, int embedding_size, const char* op) {
267 iters);
269 while (iters-- > 0) {
275 static void BM_ScatterUpdateInt32(int iters, int embedding_size) {
276 BM_ScatterHelper<int32>(iters, embedding_size, "ScatterUpdate");
278 static void BM_ScatterUpdateInt64(int iters, int embedding_size) {
279 BM_ScatterHelper<int64>(iters, embedding_size, "ScatterUpdate");
282 static void BM_ScatterAddInt32(int iters, int embedding_size) {
283 BM_ScatterHelper<int32>(iters, embedding_size, "ScatterAdd");
285 static void BM_ScatterAddInt64(int iters, int embedding_size)
[all...] |
| unique_op_test.cc | 65 static void BM_Unique_INT32(int iters, int dim, int max_int) {
78 testing::BytesProcessed(static_cast<int64>(iters) * dim * sizeof(int32));
81 test::Benchmark("cpu", g).Run(iters);
84 static void BM_Unique_INT32_Repeat(int iters, int dim, int max_int) {
98 testing::BytesProcessed(static_cast<int64>(iters) * dim * 200 *
102 test::Benchmark("cpu", g).Run(iters);
122 static void BM_Unique_STRING(int iters, int dim) {
135 testing::BytesProcessed(static_cast<int64>(iters) * dim * sizeof(string));
138 test::Benchmark("cpu", g).Run(iters);
|
| segment_reduction_ops_test.cc | 42 static void BM_SegmentReduction(int iters, const string& reduction,
85 for (int i = 0; i < iters; ++i) {
91 testing::BytesProcessed(bytes_per_iter * iters);
95 static void BM_Reduce_##O##_##R##_##C##_##S##_int32(int iters) { \
96 BM_SegmentReduction<int32>(iters, #O, R, C, S); \
98 static void BM_Reduce_##O##_##R##_##C##_##S##_int64(int iters) { \
99 BM_SegmentReduction<int64>(iters, #O, R, C, S); \
116 static void SparseSegmentMeanGradHelper(int iters, float uniqueness, int size) {
152 testing::BytesProcessed(static_cast<int64>(iters) * (kDim1 * kDim2) *
155 test::Benchmark("cpu", g).Run(iters);
[all...] |
| constant_op_test.cc | 111 static void BM_ManyConsts_Parallel(int iters, int num) {
112 testing::ItemsProcessed(static_cast<int64>(iters) * num);
113 test::Benchmark("cpu", ManyConsts(num, false /* !sequential */)).Run(iters);
117 static void BM_ManyConsts_Sequential(int iters, int num) {
118 testing::ItemsProcessed(static_cast<int64>(iters) * num);
119 test::Benchmark("cpu", ManyConsts(num, true /* sequential */)).Run(iters);
|
| split_op_test.cc | 47 static void BM_Split_1d_##num_split##_##chunk_size(int iters) { \
49 testing::ItemsProcessed(static_cast<int64>(iters) * num_split * \
57 test::Benchmark("cpu", g).Run(iters); \
64 int iters) { \
66 testing::ItemsProcessed(static_cast<int64>(iters) * num_split * \
75 test::Benchmark("cpu", g).Run(iters); \
|
| /external/tensorflow/tensorflow/examples/benchmark/ |
| sample_benchmark.py | 35 iters = 100
37 for _ in range(iters):
45 wall_time=total_wall_time/iters,
46 iters=iters)
|
| /external/compiler-rt/test/esan/TestCases/ |
| workingset-samples.cpp | 10 const int iters = 6; variable
20 for (int j = 0; j < iters; ++j) {
|
| workingset-midreport.cpp | 15 const int iters = 6; variable
25 for (int j = 0; j < iters; ++j) {
|
| /external/tensorflow/tensorflow/core/common_runtime/ |
| kernel_benchmark_testlib.h | 45 // Executes the graph for "iters" times.
46 void Run(int iters);
54 const std::vector<const Node*>& outputs, int iters);
|
| /frameworks/rs/tests/cpp_api/latency/ |
| latency.cpp | 8 int iters = 100; local
14 iters = atoi(argv[1]);
15 if (iters <= 0) {
16 printf("iters must be positive\n");
21 printf("iters = %d\n", iters);
79 for (int i = 0; i < iters; i++) {
89 printf("time per iter: %f microseconds\n", (double)elapsed / iters);
93 for (int i = 0; i < iters; i++) {
104 printf("time per iter with copy: %f microseconds\n", (double)elapsed / iters);
[all...] |
| /external/tensorflow/tensorflow/core/platform/default/ |
| test_benchmark.cc | 162 int iters; local
164 b->Run(arg.first, arg.second, &iters, &seconds);
179 seconds * 1e9 / iters, iters, full_label.c_str());
187 s = reporter.Benchmark(iters, 0.0, seconds,
212 int64 iters = kMinIters; local
220 (*fn0_)(iters);
222 (*fn1_)(iters, arg1);
224 (*fn2_)(iters, arg1, arg2);
228 if (seconds >= kMinTime || iters >= kMaxIters)
[all...] |
| /external/tensorflow/tensorflow/core/util/ |
| reporter.cc | 40 Status TestReporter::Benchmark(int64 iters, double cpu_time, double wall_time,
43 benchmark_entry_.set_iters(iters);
44 benchmark_entry_.set_cpu_time(cpu_time / iters);
45 benchmark_entry_.set_wall_time(wall_time / iters);
|
| /external/autotest/client/profilers/cpistat/ |
| cpistat | 47 iters = -1 variable
51 iters = int(args[1]) variable
65 while infinite or iters:
84 iters = iters - 1 variable
|
| /external/tensorflow/tensorflow/python/client/ |
| session_benchmark.py | 39 def _benchmarkFeed(self, name, target, size, iters):
49 iters: The number of iterations to perform.
60 for _ in xrange(iters):
66 self.report_benchmark(iters=1, wall_time=np.median(times), name=name)
68 def _benchmarkFetch(self, name, target, size, iters):
78 iters: The number of iterations to perform.
88 for _ in xrange(iters):
94 self.report_benchmark(iters=1, wall_time=np.median(times), name=name)
96 def _benchmarkFetchPrebuilt(self, name, target, size, iters):
106 iters: The number of iterations to perform
[all...] |
| /external/eigen/bench/tensors/ |
| contraction_benchmarks_cpu.cc | 15 static void BM_##Contraction##_##D1##x##D2##x##D3(int iters, int Threads) { \
19 suite.contraction(iters); \
|
