package bechamel

You can search for identifiers within the package.

in-package search v0.2.0

bechamel
- Bechamel
  - Analyze
    
    OLS
    
    RANSAC
  - Benchmark
  - Linear_algebra
  - Measure
  - Measurement_raw
  - S
    
    FUNCTOR
    
    MEASURE
  - Staged
  - Test
    
    Elt
    
    Multiple
    
    Uniq
  - Time
  - Toolkit
    
    Compaction
    
    Extension
    
    Instance
    
    Major_allocated
    
    Major_collection
    
    Minor_allocated
    
    Minor_collection
    
    Monotonic_clock
    
    One
    
    Promoted
bechamel.monotonic_clock
- Monotonic_clock

Legend:
Library
Module
Module type
Parameter
Class
Class type

Analyze module.

Micro-benchmark usually uses a linear-regression to estimates the execution time of a code segments. For example, the following table might represent {!Measurement_raw.t} array collected by Benchmark.run:

  +-----+------+
  | run | time |
  +-----+------+
  | 1   | 19   |
  | 2   | 25   |
  | 3   | 37   |
  | 4   | 47   |
  | 5   | 56   |
  +-----+------+

Bechamel records 3000 samples and the number of iterations can grows geometrically (see Benchmark.run). Then, Bechamel can use 2 algorithms:

Ordinary Least Square
RANdom SAmple Consensus

The user can choose one of it. Currently, OLS is the best to use. These algorithms will estimate the actual execution time of the code segment. Using OLS with the above data would yield an estimated execution time of 9.6 nanoseconds with a goodness of fit (r²) of 0.992.

More generally, Bechamel lets the user to choose predictors and the responder. Indeed, the user can use others metrics (such as perf) and the API allows to analyze such metrics each other.

module OLS : sig ... end

module RANSAC : sig ... end

type 'a t

Type of analyze.

val ols : r_square:bool -> bootstrap:int -> predictors:string array -> OLS.t t

ols ~r_square ~bootstrap ~predictors is an Ordinary Least Square analyze on predictors. It calculate r² if r_square = true. bootstrap is the number of how many times Bechamel try to resample measurements.

val ransac : filter_outliers:bool -> predictor:string -> RANSAC.t t

val one : 'a t -> Measure.witness -> Benchmark.t -> 'a

one analyze measure { Benchmark.stat; lr; kde; } estimates the actual given measure for one predictors. So, one analyze time { Benchmark.stat; lr; kde; } where analyze is initialized with run predictor wants to estimate actual run-time (or execution time) value.

val all : 
  'a t ->
  Measure.witness ->
  (string, Benchmark.t) Hashtbl.t ->
  (string, 'a) Hashtbl.t

all analyze measure tbl is an application of one for all results from the given tbl.

val merge : 
  'a t ->
  Measure.witness list ->
  (string, 'a) Hashtbl.t list ->
  (string, (string, 'a) Hashtbl.t) Hashtbl.t

merge witnesses tbls returns a dictionary where the key is the label of a measure (from the given witnesses) and the value is the result of this specific measure.