2863

Committed 05 Nov 2024 06:20PM UTC coverage: 30.754% (-16.6%) from 47.311%

Build # 2863

Build Type

push

buildkite

Committed by

web-flow

Commit Message

Merge pull request #16296 from MinaProtocol/dkijania/more_multi_jobs

more multi jobs in CI

Run Details

20276 of 65930 relevant lines covered (30.75%)

8631.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

47.17

/src/lib/mina_base/protocol_constants_checked.ml

open Core_kernel
open Snark_params.Tick
module T = Mina_numbers.Length

(*constants actually required for blockchain snark*)
(* k
   ,c
   ,slots_per_epoch
   ,slots_per_sub_window
   ,sub_windows_per_window
   ,checkpoint_window_size_in_slots
   ,block_window_duration_ms*)

module Poly = Genesis_constants.Protocol.Poly

module Value = struct
  [%%versioned
  module Stable = struct
    module V1 = struct
      type t =
        (T.Stable.V1.t, T.Stable.V1.t, Block_time.Stable.V1.t) Poly.Stable.V1.t
      [@@deriving equal, ord, hash, sexp, yojson]

      let to_latest = Fn.id
    end
  end]

  let gen : t Quickcheck.Generator.t =
    let open Quickcheck.Let_syntax in
    let%bind k = Int.gen_incl 1 5000 in
    let%bind delta = Int.gen_incl 0 5000 in
    let%bind slots_per_epoch = Int.gen_incl k (8 * k) >>| ( * ) 3
    and slots_per_sub_window = Int.gen_incl 1 ((k + 9) / 9) in
    let%bind grace_period_slots = Int.gen_incl 0 ((slots_per_epoch / 3) - 1) in
    (*TODO: Bug -> Block_time.(to_time x |> of_time) != x for certain values.
      Eg: 34702788243129 <--> 34702788243128, 8094 <--> 8093*)
    let%bind ms = Int64.(gen_log_uniform_incl 0L 9999999999999L) in
    let end_time = Block_time.of_int64 999999999999999L in
    let%map genesis_state_timestamp =
      Block_time.(gen_incl (of_int64 ms) end_time)
    in
    { Poly.k = T.of_int k
    ; delta = T.of_int delta
    ; slots_per_epoch = T.of_int slots_per_epoch
    ; slots_per_sub_window = T.of_int slots_per_sub_window
    ; grace_period_slots = T.of_int grace_period_slots
    ; genesis_state_timestamp
    }
end

type value = Value.t

let value_of_t
    ({ k
     ; delta
     ; slots_per_epoch
     ; slots_per_sub_window
     ; grace_period_slots
     ; genesis_state_timestamp
     } :
      Genesis_constants.Protocol.t ) : value =
  { k = T.of_int k
  ; delta = T.of_int delta
  ; slots_per_epoch = T.of_int slots_per_epoch
  ; slots_per_sub_window = T.of_int slots_per_sub_window
  ; grace_period_slots = T.of_int grace_period_slots
  ; genesis_state_timestamp = Block_time.of_int64 genesis_state_timestamp
  }

let t_of_value
    ({ k
     ; delta
     ; slots_per_epoch
     ; slots_per_sub_window
     ; grace_period_slots
     ; genesis_state_timestamp
     } :
      value ) : Genesis_constants.Protocol.t =
  { k = T.to_int k
  ; delta = T.to_int delta
  ; slots_per_epoch = T.to_int slots_per_epoch
  ; slots_per_sub_window = T.to_int slots_per_sub_window
  ; grace_period_slots = T.to_int grace_period_slots
  ; genesis_state_timestamp = Block_time.to_int64 genesis_state_timestamp
  }

let to_input
    ({ k
     ; delta
     ; slots_per_epoch
     ; slots_per_sub_window
     ; grace_period_slots
     ; genesis_state_timestamp
     } :
      value ) =
  Array.reduce_exn ~f:Random_oracle.Input.Chunked.append
    [| T.to_input k
     ; T.to_input delta
     ; T.to_input slots_per_epoch
     ; T.to_input slots_per_sub_window
     ; T.to_input grace_period_slots
     ; Block_time.to_input genesis_state_timestamp
    |]

type var = (T.Checked.t, T.Checked.t, Block_time.Checked.t) Poly.t

let typ =
  Typ.of_hlistable
    [ T.Checked.typ
    ; T.Checked.typ
    ; T.Checked.typ
    ; T.Checked.typ
    ; T.Checked.typ
    ; Block_time.Checked.typ
    ]
    ~var_to_hlist:Poly.to_hlist ~var_of_hlist:Poly.of_hlist
    ~value_to_hlist:Poly.to_hlist ~value_of_hlist:Poly.of_hlist

let var_to_input
    ({ k
     ; delta
     ; slots_per_epoch
     ; slots_per_sub_window
     ; grace_period_slots
     ; genesis_state_timestamp
     } :
      var ) =
  let k = T.Checked.to_input k
  and delta = T.Checked.to_input delta
  and slots_per_epoch = T.Checked.to_input slots_per_epoch
  and slots_per_sub_window = T.Checked.to_input slots_per_sub_window
  and grace_period_slots = T.Checked.to_input grace_period_slots in
  let genesis_state_timestamp =
    Block_time.Checked.to_input genesis_state_timestamp
  in
  Array.reduce_exn ~f:Random_oracle.Input.Chunked.append
    [| k
     ; delta
     ; slots_per_epoch
     ; slots_per_sub_window
     ; grace_period_slots
     ; genesis_state_timestamp
    |]

let%test_unit "value = var" =
  let compiled = Genesis_constants.For_unit_tests.t.protocol in
  let test protocol_constants =
    let open Snarky_backendless in
    let p_var =
      let%map p = exists typ ~compute:(As_prover0.return protocol_constants) in
      As_prover0.read typ p
    in
    let res = Or_error.ok_exn (run_and_check p_var) in
    [%test_eq: Value.t] res protocol_constants ;
    [%test_eq: Value.t] protocol_constants
      (t_of_value protocol_constants |> value_of_t)
  in
  Quickcheck.test ~trials:100 Value.gen
    ~examples:[ value_of_t compiled ]
    ~f:test

1	open Core_kernel	9✔
2	open Snark_params.Tick
3	module T = Mina_numbers.Length
4
5	(constants actually required for blockchain snark)
6	(* k
7	,c
8	,slots_per_epoch
9	,slots_per_sub_window
10	,sub_windows_per_window
11	,checkpoint_window_size_in_slots
12	,block_window_duration_ms*)
13
14	module Poly = Genesis_constants.Protocol.Poly
15
16	module Value = struct
17	[%%versioned
18	module Stable = struct
19	module V1 = struct
20	type t =	9✔
21	(T.Stable.V1.t, T.Stable.V1.t, Block_time.Stable.V1.t) Poly.Stable.V1.t	×
22	[@@deriving equal, ord, hash, sexp, yojson]	45✔
23
24	let to_latest = Fn.id
25	end
26	end]
27
28	let gen : t Quickcheck.Generator.t =
29	let open Quickcheck.Let_syntax in
30	let%bind k = Int.gen_incl 1 5000 in	9✔
31	let%bind delta = Int.gen_incl 0 5000 in	×
32	let%bind slots_per_epoch = Int.gen_incl k (8 * k) >>\| ( * ) 3	×
33	and slots_per_sub_window = Int.gen_incl 1 ((k + 9) / 9) in	×
34	let%bind grace_period_slots = Int.gen_incl 0 ((slots_per_epoch / 3) - 1) in	×
35	(*TODO: Bug -> Block_time.(to_time x \|> of_time) != x for certain values.
36	Eg: 34702788243129 <--> 34702788243128, 8094 <--> 8093*)
37	let%bind ms = Int64.(gen_log_uniform_incl 0L 9999999999999L) in	×
38	let end_time = Block_time.of_int64 999999999999999L in	×
39	let%map genesis_state_timestamp =
40	Block_time.(gen_incl (of_int64 ms) end_time)	×
41	in
42	{ Poly.k = T.of_int k	×
43	; delta = T.of_int delta	×
44	; slots_per_epoch = T.of_int slots_per_epoch	×
45	; slots_per_sub_window = T.of_int slots_per_sub_window	×
46	; grace_period_slots = T.of_int grace_period_slots	×
47	; genesis_state_timestamp
48	}
49	end
50
51	type value = Value.t
52
53	let value_of_t
54	({ k
55	; delta
56	; slots_per_epoch
57	; slots_per_sub_window
58	; grace_period_slots
59	; genesis_state_timestamp
60	} :
61	Genesis_constants.Protocol.t ) : value =
62	{ k = T.of_int k	3✔
63	; delta = T.of_int delta	3✔
64	; slots_per_epoch = T.of_int slots_per_epoch	3✔
65	; slots_per_sub_window = T.of_int slots_per_sub_window	3✔
66	; grace_period_slots = T.of_int grace_period_slots	3✔
67	; genesis_state_timestamp = Block_time.of_int64 genesis_state_timestamp	3✔
68	}
69
70	let t_of_value
71	({ k
72	; delta
73	; slots_per_epoch
74	; slots_per_sub_window
75	; grace_period_slots
76	; genesis_state_timestamp
77	} :
78	value ) : Genesis_constants.Protocol.t =
79	{ k = T.to_int k	×
80	; delta = T.to_int delta	×
81	; slots_per_epoch = T.to_int slots_per_epoch	×
82	; slots_per_sub_window = T.to_int slots_per_sub_window	×
83	; grace_period_slots = T.to_int grace_period_slots	×
84	; genesis_state_timestamp = Block_time.to_int64 genesis_state_timestamp	×
85	}
86
87	let to_input
88	({ k
89	; delta
90	; slots_per_epoch
91	; slots_per_sub_window
92	; grace_period_slots
93	; genesis_state_timestamp
94	} :
95	value ) =
96	Array.reduce_exn ~f:Random_oracle.Input.Chunked.append	806✔
97	[\| T.to_input k	806✔
98	; T.to_input delta	806✔
99	; T.to_input slots_per_epoch	806✔
100	; T.to_input slots_per_sub_window	806✔
101	; T.to_input grace_period_slots	806✔
102	; Block_time.to_input genesis_state_timestamp	806✔
103	\|]
104
105	type var = (T.Checked.t, T.Checked.t, Block_time.Checked.t) Poly.t
106
107	let typ =
108	Typ.of_hlistable	9✔
109	[ T.Checked.typ
110	; T.Checked.typ
111	; T.Checked.typ
112	; T.Checked.typ
113	; T.Checked.typ
114	; Block_time.Checked.typ
115	]
116	~var_to_hlist:Poly.to_hlist ~var_of_hlist:Poly.of_hlist
117	~value_to_hlist:Poly.to_hlist ~value_of_hlist:Poly.of_hlist
118
119	let var_to_input
120	({ k
121	; delta
122	; slots_per_epoch
123	; slots_per_sub_window
124	; grace_period_slots
125	; genesis_state_timestamp
126	} :
127	var ) =
128	let k = T.Checked.to_input k	46✔
129	and delta = T.Checked.to_input delta	46✔
130	and slots_per_epoch = T.Checked.to_input slots_per_epoch	46✔
131	and slots_per_sub_window = T.Checked.to_input slots_per_sub_window	46✔
132	and grace_period_slots = T.Checked.to_input grace_period_slots in	46✔
133	let genesis_state_timestamp =
134	Block_time.Checked.to_input genesis_state_timestamp
135	in
136	Array.reduce_exn ~f:Random_oracle.Input.Chunked.append	46✔
137	[\| k
138	; delta
139	; slots_per_epoch
140	; slots_per_sub_window
141	; grace_period_slots
142	; genesis_state_timestamp
143	\|]
144
145	let%test_unit "value = var" =
146	let compiled = Genesis_constants.For_unit_tests.t.protocol in	×
147	let test protocol_constants =
148	let open Snarky_backendless in	×
149	let p_var =
150	let%map p = exists typ ~compute:(As_prover0.return protocol_constants) in	×
151	As_prover0.read typ p	×
152	in
153	let res = Or_error.ok_exn (run_and_check p_var) in	×
154	[%test_eq: Value.t] res protocol_constants ;	×
155	[%test_eq: Value.t] protocol_constants	×
156	(t_of_value protocol_constants \|> value_of_t)	×
157	in
158	Quickcheck.test ~trials:100 Value.gen
159	~examples:[ value_of_t compiled ]	×
160	~f:test	9✔

MinaProtocol / mina / 2863

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous