Model (u.e7376c4d90716655210d16cd94a4adb6.tezos-benchmark.19.1.doc.tezos-benchmark.Tezos

Sourcetype (_, _, _) arity =

| Zero_arity : ('elt, 'elt, unit) arity
| Succ_arity : ('elt, 'b, 'a) arity -> ('elt, 'elt -> 'b, int * 'a) arity

Specifying model arity and eliminator type

Sourceval arity_0 : ('elt, 'elt, unit) arity

Sourceval arity_1 : ('elt, 'elt -> 'elt, int * unit) arity

Sourceval arity_2 : ('elt, 'elt -> 'elt -> 'elt, int * (int * unit)) arity

val arity_3 : 
  ('elt, 'elt -> 'elt -> 'elt -> 'elt, int * (int * (int * unit))) arity

Sourcemodule type Model_impl = sig ... end

Abstract representation of models. Models are strongly typed: Model_impl.arg_type exposes what a model expects on input. The relation between arg_type and model_type is encoded through a value of type arity.

Sourcetype 'arg model = (module Model_impl with type arg_type = 'arg)

Sourcetype packed_model =

| Model : _ model -> packed_model

Sourcemodule type Instantiated = sig ... end

Instantiation of a Model_impl.Def with a Costlang.S

Source

module Instantiate
  (X : Costlang.S)
  (M : Model_impl) : 
  Instantiated
    with type 'a repr = 'a X.repr
     and type size = X.size
     and type arg_type = M.arg_type

Sourcemodule type Applied = functor (X : Costlang.S) -> sig ... end

Model that has been applied to some arguments. Typically, we get an Applied model when we apply some workload from a benchmark to its model. Can be obtained with apply.

Sourcetype applied = (module Applied)

Sourcetype 'workload t =

| Abstract : {
1. conv : 'workload -> 'arg;
2. model : 'arg model;
} -> 'workload t
| Aggregate : {
1. model : 'workload -> applied;
2. sub_models : packed_model list;
} -> 'workload t

Model containers for benchmarks. We distinguish two kinds:

Abstract, which is simply a 'arg model, with a conv function that transforms a benchmark's workload into the model's arguments.
Aggregate, which is usually obtained from multiple models, a subset of which should be in sub_models.

Sourceval pp : Format.formatter -> _ t -> unit

Sourceval make : ?takes_saturation_reprs:bool -> conv:('a -> 'b) -> 'b model -> 'a t

Build _ t from _ model, with a type conversion fucntion conv. If ~takes_saturation_reprs: true is given, its generated code will take _ Saturation_reprs.t instead of int.

Source

val make_aggregated : 
  model:('a -> applied) ->
  sub_models:packed_model list ->
  'a t

Sourceval apply : 'a t -> 'a -> applied

apply takes a model and an appropriate workload, and returns an applied model

Sourceval add_model : 'a t -> 'b t -> ('a * 'b) t

Addition on models. Note that the results is always an Aggregate

Sourceval precompose : ('a -> 'b) -> 'b t -> 'a t

Transformator for the type of workloads

Sourceval get_free_variable_set : _ model -> Free_variable.Set.t

Returns the set of free variables of a model

Sourceval get_free_variable_set_of_t : _ t -> Free_variable.Set.t

Source

val get_free_variable_set_applied : 
  'workload t ->
  'workload ->
  Free_variable.Set.t

Returns the set of free variables of an applied model

Note that this can be very different from get_free_variable_set.

Commonly used abstract models Except for zero, they all require a unique name in Namespace.t, and some Free_variable.ts. Those free are deduced during the inference in Snoop, and the resulting values are (usually) the gas parameters for the protocol.

Sourceval zero : unit model

zero is the "zero" for the addition on models. It can be seen as the model of the empty code. fun () -> 0

Sourceval unknown_const1 : name:Namespace.t -> const:Free_variable.t -> unit model

Model for code that executes in constant time fun () -> const

Source

val unknown_const1_skip1 : 
  name:Namespace.t ->
  const:Free_variable.t ->
  (int * unit) model

Model ignores the arguments. fun n -> const

Source

val unknown_const1_skip2 : 
  name:Namespace.t ->
  const:Free_variable.t ->
  (int * (int * unit)) model

Model ignores the arguments. fun n m -> const

Sourceval linear : name:Namespace.t -> coeff:Free_variable.t -> (int * unit) model

fun n -> coeff × n

Source

val affine : 
  name:Namespace.t ->
  intercept:Free_variable.t ->
  coeff:Free_variable.t ->
  (int * unit) model

fun n -> intercept + coeff × n

Source

val affine_offset : 
  name:Namespace.t ->
  intercept:Free_variable.t ->
  coeff:Free_variable.t ->
  offset:int ->
  (int * unit) model

fun n -> intercept + coeff × (n - offset)

Sourceval quadratic : name:Namespace.t -> coeff:Free_variable.t -> (int * unit) model

fun n -> coeff * n²

Source

val nlogn : 
  name:Namespace.t ->
  intercept:Free_variable.t ->
  coeff:Free_variable.t ->
  (int * unit) model

fun n -> intercept + coeff × n×log(n)

Source

val nsqrtn_const : 
  name:Namespace.t ->
  intercept:Free_variable.t ->
  coeff:Free_variable.t ->
  (int * unit) model

fun n -> intercept + coeff × n×sqrt(n)

Sourceval logn : name:Namespace.t -> coeff:Free_variable.t -> (int * unit) model

fun n -> coeff * log(n)

Source

val linear_sum : 
  name:Namespace.t ->
  intercept:Free_variable.t ->
  coeff:Free_variable.t ->
  (int * (int * unit)) model

fun a b -> intercept + coeff × (a+b)

Source

val linear_sat_sub : 
  name:Namespace.t ->
  intercept:Free_variable.t ->
  coeff:Free_variable.t ->
  (int * (int * unit)) model

fun a b -> intercept + coeff × (a-b)

Source

val linear_max : 
  name:Namespace.t ->
  intercept:Free_variable.t ->
  coeff:Free_variable.t ->
  (int * (int * unit)) model

fun a b -> intercept + coeff × max(a,b)

Source

val linear_min : 
  name:Namespace.t ->
  intercept:Free_variable.t ->
  coeff:Free_variable.t ->
  (int * (int * unit)) model

fun a b -> intercept + coeff × min(a,b)

Source

val linear_min_offset : 
  name:Namespace.t ->
  intercept:Free_variable.t ->
  coeff:Free_variable.t ->
  offset:int ->
  (int * (int * unit)) model

fun a b -> intercept + coeff × (min(a,b) - offset)

Source

val linear_mul : 
  name:Namespace.t ->
  intercept:Free_variable.t ->
  coeff:Free_variable.t ->
  (int * (int * unit)) model

fun a b -> intercept + coeff × (a×b)

Source

val bilinear : 
  name:Namespace.t ->
  coeff1:Free_variable.t ->
  coeff2:Free_variable.t ->
  (int * (int * unit)) model

fun a b -> coeff1 × a + coeff2 × b

Source

val bilinear_affine : 
  name:Namespace.t ->
  intercept:Free_variable.t ->
  coeff1:Free_variable.t ->
  coeff2:Free_variable.t ->
  (int * (int * unit)) model

fun a b -> intercept + coeff1 × a + coeff2 × b

Source

val affine_skip1 : 
  name:Namespace.t ->
  intercept:Free_variable.t ->
  coeff:Free_variable.t ->
  (int * (int * unit)) model

fun a b -> intercept + coeff × b

Source

val nlogm : 
  name:Namespace.t ->
  intercept:Free_variable.t ->
  coeff:Free_variable.t ->
  (int * (int * unit)) model

fun n m -> intercept + coeff × n×log(m)

Source

val n_plus_logm : 
  name:Namespace.t ->
  intercept:Free_variable.t ->
  linear_coeff:Free_variable.t ->
  log_coeff:Free_variable.t ->
  (int * (int * unit)) model

fun n m -> intercept + (linear_coeff × n) + (log_coeff × log(m))

Source

val trilinear : 
  name:Namespace.t ->
  coeff1:Free_variable.t ->
  coeff2:Free_variable.t ->
  coeff3:Free_variable.t ->
  (int * (int * (int * unit))) model

fun a b c -> coeff1 × a + coeff2 × b + coeff3 × c

Source

val breakdown : 
  name:Namespace.t ->
  coeff1:Free_variable.t ->
  coeff2:Free_variable.t ->
  break:int ->
  (int * unit) model

A multi-affine model in two parts. The breakpoint break indicates the point at which the slope changes coefficient.

Source

val breakdown2 : 
  name:Namespace.t ->
  coeff1:Free_variable.t ->
  coeff2:Free_variable.t ->
  coeff3:Free_variable.t ->
  break1:int ->
  break2:int ->
  (int * unit) model

A multi-affine model in three parts, with breakpoints break1 and break2. Expects break1 <= break2

Source

val breakdown2_const : 
  name:Namespace.t ->
  coeff1:Free_variable.t ->
  coeff2:Free_variable.t ->
  coeff3:Free_variable.t ->
  const:Free_variable.t ->
  break1:int ->
  break2:int ->
  (int * unit) model

breakdown2 with a non-zero value at 0

Source

val breakdown2_const_offset : 
  name:Namespace.t ->
  coeff1:Free_variable.t ->
  coeff2:Free_variable.t ->
  coeff3:Free_variable.t ->
  const:Free_variable.t ->
  break1:int ->
  break2:int ->
  offset:int ->
  (int * unit) model

breakdown2 with a non-zero value at 0 and offset

Sourcemodule type Binary_operation = sig ... end

Source

val synthesize : 
  name:Namespace.t ->
  binop:(module Binary_operation) ->
  x_label:string ->
  x_model:'a model ->
  y_label:string ->
  y_model:'a model ->
  'a model

Synthesize two models of the same signature by the specified binary operation.