Evaluate typed queries over persistent maps

runtime/delta_runtime.ml

@@ -0,0 +1,90 @@
+module Pure_map = struct
+  module Ordered = struct
+    type t = int
+
+    let compare left right = if left < right then -1 else if left > right then 1 else 0
+  end
+
+  module Map = Map.Make (Ordered)
+
+  type 'a t = 'a Map.t
+
+  let empty = Map.empty
+
+  let add key value map = Map.add key value map
+
+  let remove key map = Map.remove key map
+
+  let find key map = Map.find key map
+
+  let find_opt key map = try Some (Map.find key map) with Not_found -> None
+
+  let mem key map = Map.mem key map
+
+  let cardinal map = Map.cardinal map
+
+  let is_empty map = Map.is_empty map
+
+  let bindings map = Map.bindings map
+
+  let fold f map init = Map.fold f map init
+
+  let iter f map = Map.iter f map
+
+  let map f map = Map.map f map
+
+  let keys map = Map.fold (fun key _ acc -> key :: acc) map [] |> List.rev
+
+  let equal equal_value left right = Map.equal equal_value left right
+end
+
+type counters = {
+  mutable predicate_evaluations : int;
+  mutable mapping_evaluations : int;
+  mutable changed_key_visits : int;
+  mutable full_traversals : int;
+  mutable scalar_deltas : int;
+}
+
+let new_counters () =
+  {
+    predicate_evaluations = 0;
+    mapping_evaluations = 0;
+    changed_key_visits = 0;
+    full_traversals = 0;
+    scalar_deltas = 0;
+  }
+
+let copy_counters counters =
+  {
+    predicate_evaluations = counters.predicate_evaluations;
+    mapping_evaluations = counters.mapping_evaluations;
+    changed_key_visits = counters.changed_key_visits;
+    full_traversals = counters.full_traversals;
+    scalar_deltas = counters.scalar_deltas;
+  }
+
+let reset_counters counters =
+  counters.predicate_evaluations <- 0;
+  counters.mapping_evaluations <- 0;
+  counters.changed_key_visits <- 0;
+  counters.full_traversals <- 0;
+  counters.scalar_deltas <- 0
+
+let count_predicate counters = counters.predicate_evaluations <- counters.predicate_evaluations + 1
+
+let count_mapping counters = counters.mapping_evaluations <- counters.mapping_evaluations + 1
+
+let count_changed_key counters = counters.changed_key_visits <- counters.changed_key_visits + 1
+
+let count_full_traversal counters = counters.full_traversals <- counters.full_traversals + 1
+
+let count_scalar_delta counters = counters.scalar_deltas <- counters.scalar_deltas + 1
+
+let counters_to_string counters =
+  Printf.sprintf
+    "predicate_evaluations=%d mapping_evaluations=%d changed_key_visits=%d full_traversals=%d scalar_deltas=%d"
+    counters.predicate_evaluations counters.mapping_evaluations counters.changed_key_visits
+    counters.full_traversals counters.scalar_deltas
+
+type 'a outcome = Success of 'a | Failure of string

runtime/delta_runtime.mli

@@ -0,0 +1,38 @@
+module Pure_map : sig
+  type 'a t
+
+  val empty : 'a t
+  val add : int -> 'a -> 'a t -> 'a t
+  val remove : int -> 'a t -> 'a t
+  val find : int -> 'a t -> 'a
+  val find_opt : int -> 'a t -> 'a option
+  val mem : int -> 'a t -> bool
+  val cardinal : 'a t -> int
+  val is_empty : 'a t -> bool
+  val bindings : 'a t -> (int * 'a) list
+  val fold : (int -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+  val iter : (int -> 'a -> unit) -> 'a t -> unit
+  val map : ('a -> 'b) -> 'a t -> 'b t
+  val keys : 'a t -> int list
+  val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+end
+
+type counters = {
+  mutable predicate_evaluations : int;
+  mutable mapping_evaluations : int;
+  mutable changed_key_visits : int;
+  mutable full_traversals : int;
+  mutable scalar_deltas : int;
+}
+
+val new_counters : unit -> counters
+val copy_counters : counters -> counters
+val reset_counters : counters -> unit
+val count_predicate : counters -> unit
+val count_mapping : counters -> unit
+val count_changed_key : counters -> unit
+val count_full_traversal : counters -> unit
+val count_scalar_delta : counters -> unit
+val counters_to_string : counters -> string
+
+type 'a outcome = Success of 'a | Failure of string