ceph/src/jaegertracing/opentelemetry-cpp/third_party/benchmark/bindings/python/google_benchmark/example.py

   1 # Copyright 2020 Google Inc. All rights reserved.
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #     http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14 """Example of Python using C++ benchmark framework.
  15
  16 To run this example, you must first install the `google_benchmark` Python package.
  17
  18 To install using `setup.py`, download and extract the `google_benchmark` source.
  19 In the extracted directory, execute:
  20   python setup.py install
  21 """
  22
  23 import random
  24 import time
  25
  26 import google_benchmark as benchmark
  27 from google_benchmark import Counter
  28
  29
  30 @benchmark.register
  31 def empty(state):
  32     while state:
  33         pass
  34
  35
  36 @benchmark.register
  37 def sum_million(state):
  38     while state:
  39         sum(range(1_000_000))
  40
  41 @benchmark.register
  42 def pause_timing(state):
  43     """Pause timing every iteration."""
  44     while state:
  45         # Construct a list of random ints every iteration without timing it
  46         state.pause_timing()
  47         random_list = [random.randint(0, 100) for _ in range(100)]
  48         state.resume_timing()
  49         # Time the in place sorting algorithm
  50         random_list.sort()
  51
  52
  53 @benchmark.register
  54 def skipped(state):
  55     if True:  # Test some predicate here.
  56         state.skip_with_error("some error")
  57         return  # NOTE: You must explicitly return, or benchmark will continue.
  58
  59     ...  # Benchmark code would be here.
  60
  61
  62 @benchmark.register
  63 def manual_timing(state):
  64     while state:
  65         # Manually count Python CPU time
  66         start = time.perf_counter()  # perf_counter_ns() in Python 3.7+
  67         # Something to benchmark
  68         time.sleep(0.01)
  69         end = time.perf_counter()
  70         state.set_iteration_time(end - start)
  71
  72
  73 @benchmark.register
  74 def custom_counters(state):
  75     """Collect cutom metric using benchmark.Counter."""
  76     num_foo = 0.0
  77     while state:
  78         # Benchmark some code here
  79         pass
  80         # Collect some custom metric named foo
  81         num_foo += 0.13
  82
  83     # Automatic Counter from numbers.
  84     state.counters["foo"] = num_foo
  85     # Set a counter as a rate.
  86     state.counters["foo_rate"] = Counter(num_foo, Counter.kIsRate)
  87     #  Set a counter as an inverse of rate.
  88     state.counters["foo_inv_rate"] = Counter(num_foo, Counter.kIsRate | Counter.kInvert)
  89     # Set a counter as a thread-average quantity.
  90     state.counters["foo_avg"] = Counter(num_foo, Counter.kAvgThreads)
  91     # There's also a combined flag:
  92     state.counters["foo_avg_rate"] = Counter(num_foo, Counter.kAvgThreadsRate)
  93
  94
  95 @benchmark.register
  96 @benchmark.option.measure_process_cpu_time()
  97 @benchmark.option.use_real_time()
  98 def with_options(state):
  99     while state:
 100         sum(range(1_000_000))
 101
 102
 103 @benchmark.register(name="sum_million_microseconds")
 104 @benchmark.option.unit(benchmark.kMicrosecond)
 105 def with_options(state):
 106     while state:
 107         sum(range(1_000_000))
 108
 109
 110 @benchmark.register
 111 @benchmark.option.arg(100)
 112 @benchmark.option.arg(1000)
 113 def passing_argument(state):
 114     while state:
 115         sum(range(state.range(0)))
 116
 117
 118 @benchmark.register
 119 @benchmark.option.range(8, limit=8 << 10)
 120 def using_range(state):
 121     while state:
 122         sum(range(state.range(0)))
 123
 124
 125 @benchmark.register
 126 @benchmark.option.range_multiplier(2)
 127 @benchmark.option.range(1 << 10, 1 << 18)
 128 @benchmark.option.complexity(benchmark.oN)
 129 def computing_complexity(state):
 130     while state:
 131         sum(range(state.range(0)))
 132     state.complexity_n = state.range(0)
 133
 134
 135 if __name__ == "__main__":
 136     benchmark.main()