f

Author: kris-jusiak

perf

@@ -156,9 +156,11 @@
   >   import perf; // #include <perf>
   >
   >   int main() {
-  >     erf::profiler profiler{...};
+  >     perf::profiler profiler{
+  >       perf::stat::tsc, perf::stat::cycles, perf::trace::instructions
+  >     };
   >
-  >     constexpr auto invoke = [](auto& profiler, auto&& fn, auto&&... ts) {
+  >     auto invoke = [&](auto&& fn, auto&&... ts) {
   >       profiler.start();
   >       perf::compiler::prevent_elision(fn(ts...));
   >       profiler.stop();
@@ -169,7 +171,9 @@
   >     perf::log(profiler[]);
   >     perf::verify(profiler[perf::stat::tsc] > 0ns);
   >
-  >     perf::analyzer analyzer{perf::mca::assembly, perf::mca::timeline};
+  >     perf::analyzer analyzer{
+  >       perf::mca::assembly, perf::mca::timeline
+  >     };
   >     analyzer << profiler[perf::trace::instructions];
   >
   >     perf::log(analyzer[]);
@@ -528,211 +532,6 @@
   > <details>
   >   <summary>Profiling/Analyzing</summary>
   >
-  >   ```cpp
-  >   // stat::timer
-  >   perf::stat::timer t{perf::stat::steady_time, perf::stat::cpu};
-  >
-  >   t.start();
-  >   fn();
-  >   t.stop();
-  >
-  >   assert(t[perf::stat::steady_time] > 0ns);
-  >   assert(t[perf::stat::cpu_time] > 0ns);
-  >
-  >   // `t[]` - returns std::tuple of all timers
-  >   assert(std::get<0u>(t[]) > 0ns); // steady_time
-  >   assert(std::get<1u>(t[]) > 0ns); // time_cpu
-  >   ```
-  >
-  >   ```cpp
-  >   perf::stat::tsc            - time-stamp-counter
-  >   perf::stat::steady_time    - monotonic time
-  >   perf::stat::cpu_time       - user time + sys time
-  >   perf::stat::thread_time    - cpu time for the current thread
-  >   perf::stat::real_time      - wall clock time
-  >   ```
-  >
-  >   ```cpp
-  >   // stat::counter
-  >
-  >   // metrics/dsl
-  >   // top_down
-  >   ```
-  >
-  >   ```cpp
-  >   // instruction per cycle (ipc)
-  >   ipc = instructions / cycles;
-  >
-  >   // cycles per instruction (cpi, inverse of ipc)
-  >   cpi = cycles / instructions;
-  >
-  >   // branch miss rate (branch misses per branch instruction)
-  >   branch_miss_rate = branch_misses / branches;
-  >
-  >   // cache miss rate (cache misses per cache reference)
-  >   cache_miss_rate = cache_misses / cache_references;
-  >
-  >   // llc miss rate
-  >   llc_miss_rate = llc_misses / cache_references;
-  >
-  >   // l1 data cache miss rate
-  >   l1_dcache_miss_rate = l1_dcache_load_misses / l1_dcache_loads;
-  >
-  >   // l1 instruction cache miss rate
-  >   l1_icache_miss_rate = l1_icache_load_misses / l1_icache_loads;
-  >
-  >   // dtlb miss rate
-  >   dtlb_miss_rate = dtlb_load_misses / dtlb_loads;
-  >
-  >   // itlb miss rate
-  >   itlb_miss_rate = itlb_load_misses / itlb_loads;
-  >
-  >   // stalled cycles rate (frontend)
-  >   frontend_stall_rate = stalled_cycles_frontend / cycles;
-  >
-  >   // stalled cycles rate (backend)
-  >   backend_stall_rate = stalled_cycles_backend / cycles;
-  >
-  >   // memory access rate
-  >   memory_stall_ratio = stalled_cycles_backend / cycles;
-  >
-  >   // overall stall rate
-  >   total_stall_rate = (stalled_cycles_backend + stalled_cycles_frontend) / cycles;
-  >
-  >   // cpu migrations per cycles
-  >   cpu_migration_rate = cpu_migrations / cycles;
-  >
-  >   // context switches per cycles
-  >   context_switch_rate = context_switches / cycles;
-  >
-  >   // page fault rate
-  >   page_fault_rate = faults / cycles;
-  >
-  >   // page fault rate (major faults per total faults)
-  >   major_fault_rate = major_faults / cycles;
-  >
-  >   // page fault rate (minor faults per total faults)
-  >   minor_fault_rate = minor_faults / cycles;
-  >   ```
-  >
-  >   ```cpp
-  >   // record::sampler
-  >   ```
-  >
-  >   ```cpp
-  >   // https://github.com/qlibs/prof
-  >   // prof::callgrind
-  >   // prof::...
-  >   ```
-  >
-  >   ```cpp
-  >   // trace::tracer
-  >   auto&& instructions = perf::trace::trace(
-  >     [&] { return fizz_buzz(i); }
-  >   )[perf::trace::instructions];
-  >
-  >   perf::analyzer analyzer{perf::mca::assembly};
-  >   for (auto&& i : (analyzer << instructions)[perf::mca::assembly]) {
-  >     perf::log("{}", i);
-  >   }
-  >   ```
-  >
-  >   ```cpp
-  >   // perf::analyzer
-  >   ```
-  >
-  > </details>
-  >
-  > <details>
-  >   <summary>Benchmarking</summary>
-  >
-  >   ```cpp
-  >   // perf::runner
-  >   auto&& runner = [](auto&& fn, auto&&... ts) {
-  >     perf::dataset ds{};
-  >     setat::timer timer{perf::stat::steady_time};
-  >     timer.start();
-  >     for (auto i = 0u; i < 1'000; ++i) {
-  >       compiler::prevent_elision(fn(ts...));
-  >     }
-  >     timer.stop();
-  >     ds += timer;
-  >     return ds;
-  >   };
-  >
-  >   // `runner` deduces what to run based on the usage of `bench[...]`
-  >   // unless otherwise explicilty specified
-  >   perf::runner bench{perf::named("runner", runner}};
-  >
-  >   static auto fizz_buzz = [](int n) {
-  >     if (n % 15 == 0) {
-  >       return "FizzBuzz";
-  >     } else if (n % 3 == 0) {
-  >       return "Fizz";
-  >     } else if (n % 5 == 0) {
-  >       return "Buzz";
-  >     } else {
-  >       return "Unknown";
-  >     }
-  >   };
-  >
-  >   bench(fizz_buzz, 15);
-  >   bench(fizz_buzz, 3);
-  >   bench(fizz_buzz, 5);
-  >
-  >   perf::report(bench[perf::stat::steady_time]);
-  >   ```
-  >
-  >   ```cpp
-  >   // perf::data
-  >   bench(fizz_buzz, perf::data::sequence<int>{{3,5,15}});
-  >   bench(fizz_buzz, perf::data::uniform<int>{.min = 0, .max = 15});
-  >   // choice
-  >   ```
-  >
-  >   ```cpp
-  >   // perf::bench::latency
-  >   auto add  = [](int a, int b) { return a + b; };
-  >   auto sub  = [](int a, int b) { return a - b; };
-  >   auto mult = [](int a, int b) { return a * b; };
-  >   auto div  = [](int a, int b) { return a / b; };
-  >
-  >   perf::runner bench{perf::bench::latency{}};
-  >
-  >   bench(add,  0, 0);
-  >   bench(sub,  0, 0);
-  >   bench(mult, 0, 0);
-  >   bench(div,  0, 0);
-  >
-  >   using perf::metric::operator/;
-  >   auto ops = perf::bench::operations;
-  >   perf::report(bench[perf::stat::tsc / ops, perf::stat::cycles / ops]);
-  >   ```
-  >
-  >   ```cpp
-  >   // perf::bench::throughput
-  >   ```
-  >
-  >   ```cpp
-  >   latency = time / operations;
-  >   throughput = operations / time;
-  >   inverse_throughput = time / operations;
-  >   ```
-  >
-  >   ```cpp
-  >   // perf::bench::baseline
-  >   // perf::bench::debug
-  >   ```
-  >
-  >   ```cpp
-  >   // perf::plot::hist
-  >   // perf::plot::bar
-  >   // perf::plot::box
-  >   // perf::plot::line
-  >   // perf::plot::ecdf
-  >   // perf::plot::complexity
-  >   ```
-  >
   > </details>
   >
   >  [`Synopsis`](https://github.com/qlibs/perf/blob/main/perf.cppm#L39)