text
stringlengths 0
601k
|
|---|
let add_breadcrumb_exn t breadcrumb = let open Deferred . Let_syntax in let diffs = Full_frontier . calculate_diffs t . full_frontier breadcrumb in [ % log ' trace t . logger ] logger ~ metadata : [ ( " state_hash " , State_hash . to_yojson ( Breadcrumb . state_hash ( Full_frontier . best_tip t . full_frontier ) full_frontier ) full_frontier ) ; ( " n " , ` Int ( List . length @@ Full_frontier . all_breadcrumbs t . full_frontier ) full_frontier ) ] " PRE : ( $ state_hash , $ n ) n " ; [ % str_log ' trace t . logger ] logger ( Applying_diffs { diffs = List . map ~ f : Diff . Full . E . to_yojson diffs } ) ; Catchup_tree . apply_diffs t . catchup_tree diffs ; let ( ` New_root_and_diffs_with_mutants ( new_root_identifier , diffs_with_mutants ) diffs_with_mutants ) = Full_frontier . apply_diffs t . full_frontier diffs ~ has_long_catchup_job : ( Catchup_tree . max_catchup_chain_length t . catchup_tree > 5 ) 5 ~ enable_epoch_ledger_sync ( ` : Enabled ( root_snarked_ledger t ) t ) t in Option . iter new_root_identifier ~ f ( : Persistent_root . Instance . set_root_identifier t . persistent_root_instance ) persistent_root_instance ; [ % log ' trace t . logger ] logger ~ metadata : [ ( " state_hash " , State_hash . to_yojson ( Breadcrumb . state_hash @@ Full_frontier . best_tip t . full_frontier ) full_frontier ) ; ( " n " , ` Int ( List . length @@ Full_frontier . all_breadcrumbs t . full_frontier ) full_frontier ) ] " POST : ( $ state_hash , $ n ) n " ; let user_cmds = Mina_block . Validated . valid_commands @@ Breadcrumb . validated_transition breadcrumb in [ % str_log ' trace t . logger ] logger Added_breadcrumb_user_commands ~ metadata : [ ( " user_commands " , ` List ( List . map user_cmds ~ f ( : With_status . to_yojson User_command . Valid . to_yojson ) to_yojson ) ) ; ( " state_hash " , State_hash . to_yojson ( Breadcrumb . state_hash breadcrumb ) breadcrumb ) breadcrumb ] ; let lite_diffs = List . map diffs ~ f : Diff ( . fun ( Full . E . E diff ) diff -> Lite . E . E ( to_lite diff ) diff ) diff in let % bind sync_result = Persistent_frontier . Instance . notify_sync t . persistent_frontier_instance ~ diffs : lite_diffs in sync_result |> Result . map_error ~ f ( : fun ` Sync_must_be_running -> Failure " Cannot add breadcrumb because persistent frontier sync job is not \ running , which indicates that transition frontier initialization \ has not been performed correctly " ) |> Result . ok_exn ; Extensions . notify t . extensions ~ frontier : t . full_frontier ~ diffs_with_mutants open Full_frontier let proxy1 f { full_frontier ; _ } = f full_frontier let max_length = proxy1 max_length let consensus_local_state = proxy1 consensus_local_state let all_breadcrumbs = proxy1 all_breadcrumbs let visualize ~ filename = proxy1 ( visualize ~ filename ) filename let visualize_to_string = proxy1 visualize_to_string let iter = proxy1 iter let common_ancestor = proxy1 common_ancestor let successors = proxy1 successors let successors_rec = proxy1 successors_rec let successor_hashes = proxy1 successor_hashes let successor_hashes_rec = proxy1 successor_hashes_rec let hash_path = proxy1 hash_path let best_tip = proxy1 best_tip let root = proxy1 root let find = proxy1 find let precomputed_values = proxy1 precomputed_values let genesis_constants = proxy1 genesis_constants let find_exn = proxy1 find_exn let root_length = proxy1 root_length let best_tip_path ? max_length = proxy1 ( best_tip_path ? max_length ) max_length let best_tip_path_length_exn = proxy1 best_tip_path_length_exn let find_protocol_state = proxy1 find_protocol_state let path_map ? max_length { full_frontier ; _ } breadcrumb ~ f = path_map ? max_length full_frontier breadcrumb ~ f end
|
module For_tests = struct open Signature_lib module Ledger_transfer = Mina_ledger . Ledger_transfer . Make ( Mina_ledger . Ledger ) Ledger ( Mina_ledger . Ledger . Db ) Db open Full_frontier . For_tests let proxy2 f { full_frontier = x ; _ } { full_frontier = y ; _ } = f x y let equal = proxy2 equal let load_with_max_length = load_with_max_length let rec deferred_rose_tree_iter ( Rose_tree . T ( root , trees ) trees ) trees ~ f = let % bind ( ) = f root in Deferred . List . iter trees ~ f ( : deferred_rose_tree_iter ~ f ) f let gen_genesis_breadcrumb ( ? logger = Logger . null ( ) ) ~ verifier ( ~ precomputed_values : Precomputed_values . t ) t ( ) = let constraint_constants = precomputed_values . constraint_constants in Quickcheck . Generator . create ( fun ~ size : _ ~ random : _ -> let transition_receipt_time = Some ( Time . now ( ) ) in Protocol_version ( . set_current zero ) zero ; let genesis_transition = Mina_block . Validated . lift ( Mina_block . genesis ~ precomputed_values ) precomputed_values in let genesis_ledger = Lazy . force ( Precomputed_values . genesis_ledger precomputed_values ) precomputed_values in let get_state hash = Or_error . errorf " ! Protocol state ( for scan state transactions ) transactions for \ { % sexp : State_hash . t } t not found " hash in let genesis_staged_ledger = Or_error . ok_exn ( Async . Thread_safe . block_on_async_exn ( fun ( ) -> Staged_ledger . of_scan_state_pending_coinbases_and_snarked_ledger ~ logger ~ verifier ~ constraint_constants ~ scan_state : ( Staged_ledger . Scan_state . empty ~ constraint_constants ( ) ) ~ get_state ~ pending_coinbases : ( Or_error . ok_exn @@ Pending_coinbase . create ~ depth : constraint_constants . pending_coinbase_depth ( ) ) ~ snarked_ledger : genesis_ledger ~ snarked_local_state ( : Mina_state . Local_state . empty ( ) ) ~ expected_merkle_root ( : Ledger . merkle_root genesis_ledger ) genesis_ledger ) ) in Breadcrumb . create ~ validated_transition : genesis_transition ~ staged_ledger : genesis_staged_ledger ~ just_emitted_a_proof : false ~ transition_receipt_time ) let gen_persistence ( ? logger = Logger . null ( ) ) ~ verifier ( ~ precomputed_values : Precomputed_values . t ) t ( ) = let open Core in let root_dir = " / tmp / coda_unit_test " in Quickcheck . Generator . create ( fun ~ size : _ ~ random : _ -> let uuid = Uuid_unix . create ( ) in let temp_dir = root_dir ^/ Uuid . to_string uuid in let root_dir = temp_dir ^/ " root " in let frontier_dir = temp_dir ^/ " frontier " in let cleaned = ref false in let clean_temp_dirs _ = if not ! cleaned then ( let process_info = Unix . create_process ~ prog " : rm " ~ args [ : " - rf " ; temp_dir ] in Unix . waitpid process_info . pid |> Result . map_error ~ f ( : function | ` Exit_non_zero n -> Printf . sprintf " error ( exit code % d ) d " n | ` Signal _ -> " error ( received unexpected signal ) signal " ) |> Result . ok_or_failwith ; cleaned := true ) in Unix . mkdir_p temp_dir ; Unix . mkdir root_dir ; Unix . mkdir frontier_dir ; let persistent_root = Persistent_root . create ~ logger ~ directory : root_dir ~ ledger_depth : precomputed_values . constraint_constants . ledger_depth in let persistent_frontier = Persistent_frontier . create ~ logger ~ verifier ~ time_controller ( : Block_time . Controller . basic ~ logger ) logger ~ directory : frontier_dir in Gc . Expert . add_finalizer_exn persistent_root clean_temp_dirs ; Gc . Expert . add_finalizer_exn persistent_frontier ( fun x -> Option . iter persistent_frontier . Persistent_frontier . Factory_type . instance ~ f ( : fun instance -> Persistent_frontier . Database . close instance . db ) ; Option . iter persistent_root . Persistent_root . Factory_type . instance ~ f ( : fun instance -> Ledger . Db . close instance . snarked_ledger ) snarked_ledger ; clean_temp_dirs x ) ; ( persistent_root , persistent_frontier ) persistent_frontier ) let gen_genesis_breadcrumb_with_protocol_states ~ logger ~ verifier ~ precomputed_values ( ) = let open Quickcheck . Generator . Let_syntax in let % map root = gen_genesis_breadcrumb ~ logger ~ verifier ~ precomputed_values ( ) in let protocol_states = [ ] in ( root , protocol_states ) protocol_states let gen ( ? logger = Logger . null ( ) ) ~ verifier ? trust_system ? consensus_local_state ~ precomputed_values ( ? root_ledger_and_accounts = ( Lazy . force ( Precomputed_values . genesis_ledger precomputed_values ) precomputed_values , Lazy . force ( Precomputed_values . accounts precomputed_values ) precomputed_values ) ) ( ? gen_root_breadcrumb = gen_genesis_breadcrumb_with_protocol_states ~ logger ~ verifier ~ precomputed_values ( ) ) ~ max_length ~ size ( ? use_super_catchup : bool option ) option ( ) = let open Quickcheck . Generator . Let_syntax in let trust_system = Option . value trust_system ~ default ( : Trust_system . null ( ) ) in let epoch_ledger_location = Filename . temp_dir_name ^/ " epoch_ledger " ^ ( Uuid_unix . create ( ) |> Uuid . to_string ) to_string in let consensus_local_state = Option . value consensus_local_state ~ default : ( Consensus . Data . Local_state . create ~ genesis_ledger : ( Precomputed_values . genesis_ledger precomputed_values ) precomputed_values ~ genesis_epoch_data : precomputed_values . genesis_epoch_data ~ epoch_ledger_location Public_key . Compressed . Set . empty ~ ledger_depth : precomputed_values . constraint_constants . ledger_depth ~ genesis_state_hash : ( State_hash . With_state_hashes . state_hash precomputed_values . protocol_state_with_hashes ) ) in let root_snarked_ledger , root_ledger_accounts = root_ledger_and_accounts in let % bind root , branches , protocol_states = let % bind root , protocol_states = gen_root_breadcrumb in let % map ( Rose_tree . T ( root , branches ) branches ) branches = Quickcheck . Generator . with_size ~ size ( Quickcheck_lib . gen_imperative_rose_tree ( Quickcheck . Generator . return root ) root ( Breadcrumb . For_tests . gen_non_deferred ~ logger ~ precomputed_values ~ verifier ~ trust_system ~ accounts_with_secret_keys : root_ledger_accounts ) ) in ( root , branches , protocol_states ) protocol_states in let root_data = Root_data . Limited . create ~ transition : ( External_transition . Validated . lift @@ Breadcrumb . validated_transition root ) ~ scan_state ( : Breadcrumb . staged_ledger root |> Staged_ledger . scan_state ) scan_state ~ pending_coinbase : ( Breadcrumb . staged_ledger root |> Staged_ledger . pending_coinbase_collection ) ~ protocol_states in let % map persistent_root , persistent_frontier = gen_persistence ~ logger ~ precomputed_values ~ verifier ( ) in Async . Thread_safe . block_on_async_exn ( fun ( ) -> Persistent_frontier . reset_database_exn persistent_frontier ~ root_data ~ genesis_state_hash : ( State_hash . With_state_hashes . state_hash precomputed_values . protocol_state_with_hashes ) ) ; Persistent_root . with_instance_exn persistent_root ~ f ( : fun instance -> let transition = Root_data . Limited . transition root_data in Persistent_root . Instance . set_root_state_hash instance ( Mina_block . Validated . state_hash @@ External_transition . Validated . lower transition ) ; ignore @@ Ledger_transfer . transfer_accounts ~ src : root_snarked_ledger ~ dest ( : Persistent_root . Instance . snarked_ledger instance ) instance ) ; let frontier_result = Async . Thread_safe . block_on_async_exn ( fun ( ) -> load_with_max_length ~ max_length ~ retry_with_fresh_db : false ~ logger ~ verifier ~ consensus_local_state ~ persistent_root ~ catchup_mode : ( match use_super_catchup with | Some true -> ` Super | Some false -> ` Normal | None -> ` Normal ) ~ persistent_frontier ~ precomputed_values ( ) ) in let frontier = let fail msg = failwith ( " failed to load transition frontier : " ^ msg ) msg in match frontier_result with | Error ` Bootstrap_required -> fail " bootstrap required " | Error ` Persistent_frontier_malformed -> fail " persistent frontier malformed " | Error ` Snarked_ledger_mismatch -> fail " persistent frontier is out of sync with snarked ledger " | Error ( ` Failure msg ) msg -> fail msg | Ok frontier -> frontier in Async . Thread_safe . block_on_async_exn ( fun ( ) -> Deferred . List . iter ~ how ` : Sequential branches ~ f ( : deferred_rose_tree_iter ~ f ( : add_breadcrumb_exn frontier ) frontier ) frontier ) ; Core . Gc . Expert . add_finalizer_exn consensus_local_state ( fun consensus_local_state -> Consensus . Data . Local_state ( . Snapshot . Ledger_snapshot . close @@ staking_epoch_ledger consensus_local_state ) consensus_local_state ; Consensus . Data . Local_state ( . Snapshot . Ledger_snapshot . close @@ next_epoch_ledger consensus_local_state ) consensus_local_state ) ; frontier let gen_with_branch ? logger ~ verifier ? trust_system ? consensus_local_state ~ precomputed_values ( ? root_ledger_and_accounts = ( Lazy . force ( Precomputed_values . genesis_ledger precomputed_values ) precomputed_values , Lazy . force ( Precomputed_values . accounts precomputed_values ) precomputed_values ) ) ? gen_root_breadcrumb ( ? get_branch_root = root ) root ~ max_length ~ frontier_size ~ branch_size ( ? use_super_catchup : bool option ) option ( ) = let open Quickcheck . Generator . Let_syntax in let % bind frontier = gen ? logger ~ verifier ? trust_system ? use_super_catchup ? consensus_local_state ~ precomputed_values ? gen_root_breadcrumb ~ root_ledger_and_accounts ~ max_length ~ size : frontier_size ( ) in let % map make_branch = Breadcrumb . For_tests . gen_seq ? logger ~ precomputed_values ~ verifier ? trust_system ~ accounts_with_secret_keys ( : snd root_ledger_and_accounts ) root_ledger_and_accounts branch_size in let branch = Async . Thread_safe . block_on_async_exn ( fun ( ) -> make_branch ( get_branch_root frontier ) frontier ) in ( frontier , branch ) branch end
|
module type Transition_handler_validator_intf = sig type unprocessed_transition_cache type transition_frontier val run : logger : Logger . t -> trust_system : Trust_system . t -> time_controller : Block_time . Controller . t -> frontier : transition_frontier -> transition_reader : Mina_block . initial_valid_block Envelope . Incoming . t Strict_pipe . Reader . t -> valid_transition_writer : ( ( Mina_block . initial_valid_block Envelope . Incoming . t , State_hash . t ) Cached . t , Strict_pipe . drop_head Strict_pipe . buffered , unit ) Strict_pipe . Writer . t -> unprocessed_transition_cache : unprocessed_transition_cache -> unit val validate_transition : logger : Logger . t -> frontier : transition_frontier -> unprocessed_transition_cache : unprocessed_transition_cache -> Mina_block . initial_valid_block Envelope . Incoming . t -> ( ( Mina_block . initial_valid_block Envelope . Incoming . t , State_hash . t ) Cached . t , [ > ` In_frontier of State_hash . t | ` In_process of State_hash . t Cache_lib . Intf . final_state | ` Disconnected ] ) Result . t end
|
module type Breadcrumb_builder_intf = sig type transition_frontier type transition_frontier_breadcrumb val build_subtrees_of_breadcrumbs : logger : Logger . t -> verifier : Verifier . t -> trust_system : Trust_system . t -> frontier : transition_frontier -> initial_hash : State_hash . t -> ( Mina_block . initial_valid_block Envelope . Incoming . t , State_hash . t ) Cached . t Rose_tree . t List . t -> ( transition_frontier_breadcrumb , State_hash . t ) t Cached . t Rose_tree . t List . t Deferred . Or_error . t end
|
module type Transition_handler_processor_intf = sig type transition_frontier type transition_frontier_breadcrumb val run : logger : Logger . t -> verifier : Verifier . t -> trust_system : Trust_system . t -> time_controller : Block_time . Controller . t -> frontier : transition_frontier -> primary_transition_reader : ( Mina_block . initial_valid_block Envelope . Incoming . t , State_hash . t ) Cached . t Strict_pipe . Reader . t -> producer_transition_reader : transition_frontier_breadcrumb Strict_pipe . Reader . t -> clean_up_catchup_scheduler : unit Ivar . t -> catchup_job_writer : ( State_hash . t * ( Mina_block . initial_valid_block Envelope . Incoming . t , State_hash . t ) Cached . t Rose_tree . t list , Strict_pipe . crash Strict_pipe . buffered , unit ) Strict_pipe . Writer . t -> catchup_breadcrumbs_reader : ( ( transition_frontier_breadcrumb , State_hash . t ) t Cached . t Rose_tree . t list * [ ` Ledger_catchup of unit Ivar . t | ` Catchup_scheduler ] ) Strict_pipe . Reader . t -> catchup_breadcrumbs_writer : ( ( transition_frontier_breadcrumb , State_hash . t ) t Cached . t Rose_tree . t list * [ ` Ledger_catchup of unit Ivar . t | ` Catchup_scheduler ] , Strict_pipe . crash Strict_pipe . buffered , unit ) Strict_pipe . Writer . t -> processed_transition_writer : ( [ ` Transition of Mina_block . Validated . t ] * [ ` Source of [ ` Gossip | ` Catchup | ` Internal ] ] , Strict_pipe . crash Strict_pipe . buffered , unit ) Strict_pipe . Writer . t -> unit end
|
module type Unprocessed_transition_cache_intf = sig type t val create : logger : Logger . t -> t val register_exn : t -> Mina_block . initial_valid_block Envelope . Incoming . t -> ( Mina_block . initial_valid_block Envelope . Incoming . t , State_hash . t ) Cached . t end
|
module type Transition_handler_intf = sig type transition_frontier type transition_frontier_breadcrumb module Unprocessed_transition_cache : Unprocessed_transition_cache_intf module Breadcrumb_builder : Breadcrumb_builder_intf with type transition_frontier := transition_frontier and type transition_frontier_breadcrumb := transition_frontier_breadcrumb module Validator : Transition_handler_validator_intf with type unprocessed_transition_cache := Unprocessed_transition_cache . t and type transition_frontier := transition_frontier module Processor : Transition_handler_processor_intf with type transition_frontier := transition_frontier and type transition_frontier_breadcrumb := transition_frontier_breadcrumb end
|
module type Best_tip_prover_intf = sig type transition_frontier val prove : logger : Logger . t -> transition_frontier -> ( Mina_block . t State_hash . With_state_hashes . t , State_body_hash . t list * Mina_block . t ) Proof_carrying_data . t option val verify : verifier : Verifier . t -> genesis_constants : Genesis_constants . t -> precomputed_values : Precomputed_values . t -> ( Mina_block . t , State_body_hash . t list * Mina_block . t ) Proof_carrying_data . t -> ( [ ` Root of Mina_block . initial_valid_block ] * [ ` Best_tip of Mina_block . initial_valid_block ] ) Deferred . Or_error . t end
|
module type Consensus_best_tip_prover_intf = sig type transition_frontier val prove : logger : Logger . t -> consensus_constants : Consensus . Constants . t -> frontier : transition_frontier -> Consensus . Data . Consensus_state . Value . t State_hash . With_state_hashes . t -> ( Mina_block . t , State_body_hash . t list * Mina_block . t ) Proof_carrying_data . t option val verify : logger : Logger . t -> verifier : Verifier . t -> consensus_constants : Consensus . Constants . t -> genesis_constants : Genesis_constants . t -> precomputed_values : Precomputed_values . t -> Consensus . Data . Consensus_state . Value . t State_hash . With_state_hashes . t -> ( Mina_block . t , State_body_hash . t list * Mina_block . t ) Proof_carrying_data . t -> ( [ ` Root of Mina_block . initial_valid_block ] * [ ` Best_tip of Mina_block . initial_valid_block ] ) Deferred . Or_error . t end
|
module type Sync_handler_intf = sig type transition_frontier val answer_query : frontier : transition_frontier -> Ledger_hash . t -> Mina_ledger . Sync_ledger . Query . t Envelope . Incoming . t -> logger : Logger . t -> trust_system : Trust_system . t -> Mina_ledger . Sync_ledger . Answer . t option Deferred . t val get_staged_ledger_aux_and_pending_coinbases_at_hash : frontier : transition_frontier -> State_hash . t -> ( Staged_ledger . Scan_state . t * Ledger_hash . t * Pending_coinbase . t * Mina_state . Protocol_state . value list ) Option . t val get_transition_chain : frontier : transition_frontier -> State_hash . t list -> Mina_block . t list option val best_tip_path : frontier : transition_frontier -> State_hash . t list module Root : Consensus_best_tip_prover_intf with type transition_frontier := transition_frontier end
|
module type Transition_chain_prover_intf = sig type transition_frontier val prove : ? length : int -> frontier : transition_frontier -> State_hash . t -> ( State_hash . t * State_body_hash . t list ) list option end
|
module type Bootstrap_controller_intf = sig type network type transition_frontier type persistent_root type persistent_frontier val run : logger : Logger . t -> trust_system : Trust_system . t -> verifier : Verifier . t -> network : network -> consensus_local_state : Consensus . Data . Local_state . t -> transition_reader : Mina_block . initial_valid_block Envelope . Incoming . t Strict_pipe . Reader . t -> persistent_root : persistent_root -> persistent_frontier : persistent_frontier -> initial_root_transition : Mina_block . Validated . t -> genesis_state_hash : State_hash . t -> genesis_ledger : Mina_ledger . Ledger . t Lazy . t -> genesis_constants : Genesis_constants . t -> ( transition_frontier * Mina_block . initial_valid_block Envelope . Incoming . t list ) Deferred . t end
|
module type Transition_frontier_controller_intf = sig type transition_frontier type breadcrumb type network val run : logger : Logger . t -> trust_system : Trust_system . t -> verifier : Verifier . t -> network : network -> time_controller : Block_time . Controller . t -> collected_transitions : Mina_block . initial_valid_block Envelope . Incoming . t list -> frontier : transition_frontier -> network_transition_reader : Mina_block . initial_valid_block Envelope . Incoming . t Strict_pipe . Reader . t -> producer_transition_reader : breadcrumb Strict_pipe . Reader . t -> clear_reader [ : ` Clear ] Strict_pipe . Reader . t -> Mina_block . Validated . t Strict_pipe . Reader . t end
|
module type Transition_router_intf = sig type transition_frontier type transition_frontier_persistent_root type transition_frontier_persistent_frontier type breadcrumb type network val run : logger : Logger . t -> trust_system : Trust_system . t -> verifier : Verifier . t -> network : network -> is_seed : bool -> is_demo_mode : bool -> time_controller : Block_time . Controller . t -> consensus_local_state : Consensus . Data . Local_state . t -> persistent_root_location : string -> persistent_frontier_location : string -> frontier_broadcast_pipe : transition_frontier option Pipe_lib . Broadcast_pipe . Reader . t * transition_frontier option Pipe_lib . Broadcast_pipe . Writer . t -> network_transition_reader : ( [ ` Transition of Mina_block . t Envelope . Incoming . t ] * [ ` Time_received of Block_time . t ] * [ ` Valid_cb of Mina_net2 . Validation_callback . t ] ) Strict_pipe . Reader . t -> producer_transition_reader : breadcrumb Strict_pipe . Reader . t -> most_recent_valid_block : Mina_block . initial_valid_block Broadcast_pipe . Reader . t * Mina_block . initial_valid_block Broadcast_pipe . Writer . t -> precomputed_values : Precomputed_values . t -> catchup_mode [ : ` Normal | ` Super ] -> notify_online ( : unit -> unit Deferred . t ) t -> ( [ ` Transition of Mina_block . Validated . t ] * [ ` Source of [ ` Gossip | ` Catchup | ` Internal ] ] * [ ` Valid_cb of Mina_net2 . Validation_callback . t option ] ) Strict_pipe . Reader . t * unit Ivar . t end
|
let run ~ logger ~ trust_system ~ verifier ~ network ~ time_controller ~ collected_transitions ~ frontier ~ network_transition_reader ~ producer_transition_reader ~ clear_reader ~ precomputed_values = let valid_transition_pipe_capacity = 50 in let start_time = Time . now ( ) in let f_drop_head name head valid_cb = let block : Mina_block . initial_valid_block = Network_peer . Envelope . Incoming . data @@ Cache_lib . Cached . peek head in Mina_block . handle_dropped_transition ( Validation . block_with_hash block |> With_hash . hash ) hash ? valid_cb ~ pipe_name : name ~ logger in let valid_transition_reader , valid_transition_writer = let name = " valid transitions " in Strict_pipe . create ~ name ( Buffered ( ` Capacity valid_transition_pipe_capacity , ` Overflow ( Drop_head ( fun ( ` Block head , ` Valid_cb vc ) vc -> Mina_metrics ( . Counter . inc_one Pipe . Drop_on_overflow . transition_frontier_valid_transitions ) transition_frontier_valid_transitions ; f_drop_head name head vc ) ) ) ) in let primary_transition_pipe_capacity = valid_transition_pipe_capacity + List . length collected_transitions in let primary_transition_reader , primary_transition_writer = let name = " primary transitions " in Strict_pipe . create ~ name ( Buffered ( ` Capacity primary_transition_pipe_capacity , ` Overflow ( Drop_head ( fun ( ` Block head , ` Valid_cb vc ) vc -> Mina_metrics ( . Counter . inc_one Pipe . Drop_on_overflow . transition_frontier_primary_transitions ) transition_frontier_primary_transitions ; f_drop_head name head vc ) ) ) ) in let processed_transition_reader , processed_transition_writer = Strict_pipe . create ~ name " : processed transitions " ( Buffered ( ` Capacity 30 , ` Overflow Crash ) Crash ) Crash in let catchup_job_reader , catchup_job_writer = Strict_pipe . create ~ name " : catchup jobs " ( Buffered ( ` Capacity 30 , ` Overflow Crash ) Crash ) Crash in let catchup_breadcrumbs_reader , catchup_breadcrumbs_writer = Strict_pipe . create ~ name " : catchup breadcrumbs " ( Buffered ( ` Capacity 30 , ` Overflow Crash ) Crash ) Crash in let unprocessed_transition_cache = Transition_handler . Unprocessed_transition_cache . create ~ logger in List . iter collected_transitions ~ f ( : fun t -> let block_cached = Transition_handler . Unprocessed_transition_cache . register_exn unprocessed_transition_cache t in Strict_pipe . Writer . write primary_transition_writer ( ` Block block_cached , ` Valid_cb None ) None ) ; let initial_state_hashes = List . map collected_transitions ~ f ( : fun envelope -> Network_peer . Envelope . Incoming . data envelope |> Validation . block_with_hash |> Mina_base . State_hash . With_state_hashes . state_hash ) |> Mina_base . State_hash . Set . of_list in let extensions = Transition_frontier . extensions frontier in don ' t_wait_for @@ Pipe_lib . Broadcast_pipe . Reader . iter_until ( Transition_frontier . Extensions . get_view_pipe extensions New_breadcrumbs ) New_breadcrumbs ~ f ( : fun new_breadcrumbs -> let open Mina_base . State_hash in let new_state_hashes = List . map new_breadcrumbs ~ f : Transition_frontier . Breadcrumb . state_hash |> Set . of_list in if Set . is_empty @@ Set . inter initial_state_hashes new_state_hashes then Deferred . return false else ( Mina_metrics ( . Gauge . set Catchup . initial_catchup_time Time ( . Span . to_min @@ diff ( now ( ) ) start_time ) start_time ) start_time ; Deferred . return true ) ) ; Transition_handler . Validator . run ~ consensus_constants : ( Precomputed_values . consensus_constants precomputed_values ) precomputed_values ~ logger ~ trust_system ~ time_controller ~ frontier ~ transition_reader : network_transition_reader ~ valid_transition_writer ~ unprocessed_transition_cache ; Strict_pipe . Reader . iter_without_pushback valid_transition_reader ~ f ( : fun ( ` Block b , ` Valid_cb vc ) vc -> Strict_pipe . Writer . write primary_transition_writer ( ` Block b , ` Valid_cb vc ) vc ) |> don ' t_wait_for ; let clean_up_catchup_scheduler = Ivar . create ( ) in Transition_handler . Processor . run ~ logger ~ precomputed_values ~ time_controller ~ trust_system ~ verifier ~ frontier ~ primary_transition_reader ~ producer_transition_reader ~ clean_up_catchup_scheduler ~ catchup_job_writer ~ catchup_breadcrumbs_reader ~ catchup_breadcrumbs_writer ~ processed_transition_writer ; Ledger_catchup . run ~ logger ~ precomputed_values ~ trust_system ~ verifier ~ network ~ frontier ~ catchup_job_reader ~ catchup_breadcrumbs_writer ~ unprocessed_transition_cache ; Strict_pipe . Reader . iter_without_pushback clear_reader ~ f ( : fun _ -> let open Strict_pipe . Writer in kill valid_transition_writer ; kill primary_transition_writer ; kill processed_transition_writer ; kill catchup_job_writer ; kill catchup_breadcrumbs_writer ; if Ivar . is_full clean_up_catchup_scheduler then [ % log error ] error " Ivar . fill bug is here " ! ; Ivar . fill clean_up_catchup_scheduler ( ) ) |> don ' t_wait_for ; processed_transition_reader
|
( module struct let max_length = 5 module Stubs = Stubs . Make ( struct let max_length = max_length end ) end open Stubs let breadcrumbs_path = Transition_frontier . root_history_path_map ~ f : Fn . id let accounts_with_secret_keys = Test_genesis_ledger . accounts let create_root_frontier = create_root_frontier accounts_with_secret_keys let create_breadcrumbs ~ logger ~ pids ~ trust_system ~ size root = Deferred . all @@ Quickcheck . random_value ( gen_linear_breadcrumbs ~ logger ~ pids ~ trust_system ~ size ~ accounts_with_secret_keys root ) root let breadcrumb_trail_equals = List . equal Transition_frontier . Breadcrumb . equal let logger = Logger . null ( ) let hb_logger = Logger . create ( ) let pids = Child_processes . Termination . create_pid_table ( ) let trust_system = Trust_system . null ( ) let % test " If a transition does not exists in the transition_frontier or \ in the root_history , then we should not get an answer " = heartbeat_flag := true ; Async . Thread_safe . block_on_async_exn ( fun ( ) -> print_heartbeat hb_logger |> don ' t_wait_for ; let % bind frontier = create_root_frontier ~ logger ~ pids in let root = Transition_frontier . root frontier in let % bind breadcrumbs = create_breadcrumbs ~ logger ~ pids ~ trust_system ~ size : max_length root in let last_breadcrumb , breadcrumbs_to_add = let rev_breadcrumbs = List . rev breadcrumbs in ( List . hd_exn rev_breadcrumbs , List . rev @@ List . tl_exn rev_breadcrumbs ) in let % map ( ) = Deferred . List . iter breadcrumbs_to_add ~ f ( : fun breadcrumb -> Transition_frontier . add_breadcrumb_exn frontier breadcrumb ) in let res = Option . is_none ( breadcrumbs_path frontier @@ Transition_frontier . Breadcrumb . state_hash last_breadcrumb ) in heartbeat_flag := false ; res ) let % test " Query transition only from transition_frontier if the \ root_history is empty " = Backtrace . elide := false ; Async . Scheduler . set_record_backtraces true ; Async . Thread_safe . block_on_async_exn ( fun ( ) -> print_heartbeat hb_logger |> don ' t_wait_for ; let % bind frontier = create_root_frontier ~ logger ~ pids in let root = Transition_frontier . root frontier in let % bind breadcrumbs = create_breadcrumbs ~ logger ~ pids ~ trust_system ~ size : max_length root in let % map ( ) = Deferred . List . iter breadcrumbs ~ f ( : Transition_frontier . add_breadcrumb_exn frontier ) frontier in let random_index = Quickcheck . random_value ( Int . gen_incl 0 ( max_length - 1 ) 1 ) 1 in let random_breadcrumb = List ( . nth_exn breadcrumbs random_index ) random_index in let queried_breadcrumbs = breadcrumbs_path frontier @@ Transition_frontier . Breadcrumb . state_hash random_breadcrumb |> Option . value_exn |> Non_empty_list . to_list in assert ( Transition_frontier . For_tests . root_history_is_empty frontier ) frontier ; let expected_breadcrumbs = Transition_frontier . root frontier :: List . take breadcrumbs ( random_index + 1 ) 1 in heartbeat_flag := false ; breadcrumb_trail_equals expected_breadcrumbs queried_breadcrumbs ) let % test " Query transitions only from root_history " = heartbeat_flag := true ; Async . Thread_safe . block_on_async_exn ( fun ( ) -> print_heartbeat hb_logger |> don ' t_wait_for ; let % bind frontier = create_root_frontier ~ logger ~ pids in let root = Transition_frontier . root frontier in let query_index = 1 in let size = max_length + query_index + 2 in let % bind breadcrumbs = create_breadcrumbs ~ logger ~ pids ~ trust_system ~ size root in let % map ( ) = Deferred . List . iter breadcrumbs ~ f ( : fun breadcrumb -> Transition_frontier . add_breadcrumb_exn frontier breadcrumb ) in let query_breadcrumb = List . nth_exn breadcrumbs query_index in let expected_breadcrumbs = root :: List . take breadcrumbs ( query_index + 1 ) 1 in let query_hash = Transition_frontier . Breadcrumb . state_hash query_breadcrumb in assert ( Transition_frontier . For_tests . root_history_mem frontier query_hash ) ; heartbeat_flag := false ; List . equal Transition_frontier . Breadcrumb . equal expected_breadcrumbs ( breadcrumbs_path frontier query_hash |> Option . value_exn |> Non_empty_list . to_list ) ) let % test " moving the root removes the old root ' s non - heir children as \ garbage " = heartbeat_flag := true ; Async . Thread_safe . block_on_async_exn ( fun ( ) -> print_heartbeat hb_logger |> don ' t_wait_for ; let % bind frontier = create_root_frontier ~ logger ~ pids in let % bind ( ) = add_linear_breadcrumbs ~ logger ~ pids ~ trust_system ~ size : max_length ~ accounts_with_secret_keys ~ frontier ~ parent ( : Transition_frontier . root frontier ) frontier in let add_child = add_child ~ logger ~ trust_system ~ accounts_with_secret_keys ~ frontier in let % bind soon_garbage = add_child ~ parent ( : Transition_frontier . root frontier ) frontier in let % map _ = add_child ~ parent ( : Transition_frontier . best_tip frontier ) frontier ~ pids in let res = Transition_frontier ( . find frontier @@ Breadcrumb . state_hash soon_garbage ) soon_garbage |> Option . is_none in heartbeat_flag := false ; res ) let % test " Transitions get popped off from root history " = heartbeat_flag := true ; Async . Thread_safe . block_on_async_exn ( fun ( ) -> print_heartbeat hb_logger |> don ' t_wait_for ; let % bind frontier = create_root_frontier ~ logger ~ pids in let root = Transition_frontier . root frontier in let root_hash = Transition_frontier . Breadcrumb . state_hash root in let size = ( 3 * max_length ) max_length + 1 in let % map ( ) = build_frontier_randomly frontier ~ gen_root_breadcrumb_builder : ( gen_linear_breadcrumbs ~ logger ~ pids ~ trust_system ~ size ~ accounts_with_secret_keys ) accounts_with_secret_keys in assert ( not @@ Transition_frontier . For_tests . root_history_mem frontier root_hash ) ; let res = Transition_frontier . find frontier root_hash |> Option . is_empty in heartbeat_flag := false ; res ) let % test " Get transitions from both transition frontier and root history " = heartbeat_flag := true ; Async . Thread_safe . block_on_async_exn ( fun ( ) -> print_heartbeat hb_logger |> don ' t_wait_for ; let % bind frontier = create_root_frontier ~ logger ~ pids in let root = Transition_frontier . root frontier in let num_root_history_breadcrumbs = Quickcheck . random_value ( Int . gen_incl 1 ( 2 * max_length ) max_length ) max_length in let % bind root_history_breadcrumbs = create_breadcrumbs ~ logger ~ pids ~ trust_system ~ size : num_root_history_breadcrumbs root in let most_recent_breadcrumb_in_root_history_breadcrumb = List . last_exn root_history_breadcrumbs in let % bind transition_frontier_breadcrumbs = create_breadcrumbs ~ logger ~ pids ~ trust_system ~ size : max_length most_recent_breadcrumb_in_root_history_breadcrumb in let random_breadcrumb_index = Quickcheck . random_value ( Int . gen_incl 0 ( max_length - 1 ) 1 ) 1 in let random_breadcrumb_hash = Transition_frontier . Breadcrumb . state_hash ( List . nth_exn transition_frontier_breadcrumbs random_breadcrumb_index ) random_breadcrumb_index in let expected_breadcrumb_trail = ( root :: root_history_breadcrumbs ) root_history_breadcrumbs @ List . take transition_frontier_breadcrumbs ( random_breadcrumb_index + 1 ) 1 in let % map ( ) = Deferred . List . iter ( root_history_breadcrumbs @ transition_frontier_breadcrumbs ) transition_frontier_breadcrumbs ~ f ( : fun breadcrumb -> Transition_frontier . add_breadcrumb_exn frontier breadcrumb ) in let result = breadcrumbs_path frontier random_breadcrumb_hash |> Option . value_exn |> Non_empty_list . to_list in heartbeat_flag := false ; List . equal Transition_frontier . Breadcrumb . equal expected_breadcrumb_trail result ) end ) ) *
|
type Structured_log_events . t += Starting_transition_frontier_controller [ @@ deriving register_event { msg = " Starting transition frontier controller phase " } ]
|
type Structured_log_events . t += Starting_bootstrap_controller [ @@ deriving register_event { msg = " Starting bootstrap controller phase " } ]
|
let create_bufferred_pipe ? name ~ f ( ) = Strict_pipe . create ? name ( Buffered ( ` Capacity 50 , ` Overflow ( Drop_head f ) f ) f ) f
|
let is_transition_for_bootstrap ~ logger ( ~ precomputed_values : Precomputed_values . t ) t frontier new_transition = let root_consensus_state = Transition_frontier . root frontier |> Transition_frontier . Breadcrumb . consensus_state_with_hashes in let new_consensus_state = Validation . block_with_hash new_transition |> With_hash . map ~ f : Mina_block . consensus_state in let constants = precomputed_values . consensus_constants in match Consensus . Hooks . select ~ constants ~ existing : root_consensus_state ~ candidate : new_consensus_state ~ logger with | ` Keep -> false | ` Take -> let slack = 5 in if Length . to_int ( Transition_frontier . best_tip frontier |> Transition_frontier . Breadcrumb . consensus_state |> Consensus . Data . Consensus_state . blockchain_length ) + 290 + slack < Length . to_int ( Consensus . Data . Consensus_state . blockchain_length new_consensus_state . data ) then true else Consensus . Hooks . should_bootstrap ~ constants ~ existing : root_consensus_state ~ candidate : new_consensus_state ~ logger : ( Logger . extend logger [ ( " selection_context " , ` String " Transition_router . is_transition_for_bootstrap " ) ] )
|
let start_transition_frontier_controller ~ logger ~ trust_system ~ verifier ~ network ~ time_controller ~ producer_transition_reader_ref ~ producer_transition_writer_ref ~ verified_transition_writer ~ clear_reader ~ collected_transitions ~ transition_reader_ref ~ transition_writer_ref ~ frontier_w ~ precomputed_values frontier = [ % str_log info ] info Starting_transition_frontier_controller ; let ( transition_frontier_controller_reader , transition_frontier_controller_writer ) = let name = " transition frontier controller pipe " in create_bufferred_pipe ~ name ~ f ( : fun ( ` Block block , ` Valid_cb valid_cb ) valid_cb -> Mina_metrics ( . Counter . inc_one Pipe . Drop_on_overflow . router_transition_frontier_controller ) router_transition_frontier_controller ; Mina_block . handle_dropped_transition ( With_hash . hash @@ Validation . block_with_hash @@ Network_peer . Envelope . Incoming . data block ) ? valid_cb ~ pipe_name : name ~ logger ) ( ) in transition_reader_ref := transition_frontier_controller_reader ; transition_writer_ref := transition_frontier_controller_writer ; let producer_transition_reader , producer_transition_writer = Strict_pipe . create ~ name " : transition frontier : producer transition " Synchronous in producer_transition_reader_ref := producer_transition_reader ; producer_transition_writer_ref := producer_transition_writer ; Broadcast_pipe . Writer . write frontier_w ( Some frontier ) frontier |> don ' t_wait_for ; let new_verified_transition_reader = Transition_frontier_controller . run ~ logger ~ trust_system ~ verifier ~ network ~ time_controller ~ collected_transitions ~ frontier ~ network_transition_reader :! transition_reader_ref ~ producer_transition_reader ~ clear_reader ~ precomputed_values in Strict_pipe . Reader . iter new_verified_transition_reader ~ f : ( Fn . compose Deferred . return ( Strict_pipe . Writer . write verified_transition_writer ) verified_transition_writer ) |> don ' t_wait_for
|
let start_bootstrap_controller ~ logger ~ trust_system ~ verifier ~ network ~ time_controller ~ producer_transition_reader_ref ~ producer_transition_writer_ref ~ verified_transition_writer ~ clear_reader ~ transition_reader_ref ~ transition_writer_ref ~ consensus_local_state ~ frontier_w ~ initial_root_transition ~ persistent_root ~ persistent_frontier ~ best_seen_transition ~ precomputed_values ~ catchup_mode = [ % str_log info ] info Starting_bootstrap_controller ; [ % log info ] info " Starting Bootstrap Controller phase " ; let bootstrap_controller_reader , bootstrap_controller_writer = let name = " bootstrap controller pipe " in create_bufferred_pipe ~ name ~ f ( : fun ( ` Block head , ` Valid_cb valid_cb ) valid_cb -> Mina_metrics ( . Counter . inc_one Pipe . Drop_on_overflow . router_bootstrap_controller ) router_bootstrap_controller ; Mina_block . handle_dropped_transition ( With_hash . hash @@ Validation . block_with_hash @@ Network_peer . Envelope . Incoming . data head ) ~ pipe_name : name ~ logger ? valid_cb ) ( ) in transition_reader_ref := bootstrap_controller_reader ; transition_writer_ref := bootstrap_controller_writer ; let producer_transition_reader , producer_transition_writer = Strict_pipe . create ~ name " : bootstrap controller : producer transition " Synchronous in producer_transition_reader_ref := producer_transition_reader ; producer_transition_writer_ref := producer_transition_writer ; Option . iter best_seen_transition ~ f ( : fun block -> Strict_pipe . Writer . write bootstrap_controller_writer ( ` Block block , ` Valid_cb None ) None ) ; don ' t_wait_for ( Broadcast_pipe . Writer . write frontier_w None ) None ; upon ( Bootstrap_controller . run ~ logger ~ trust_system ~ verifier ~ network ~ consensus_local_state ~ transition_reader :! transition_reader_ref ~ persistent_frontier ~ persistent_root ~ initial_root_transition ~ best_seen_transition ~ precomputed_values ~ catchup_mode ) ( fun ( new_frontier , collected_transitions ) collected_transitions -> Strict_pipe . Writer . kill ! transition_writer_ref ; start_transition_frontier_controller ~ logger ~ trust_system ~ verifier ~ network ~ time_controller ~ producer_transition_reader_ref ~ producer_transition_writer_ref ~ verified_transition_writer ~ clear_reader ~ collected_transitions ~ transition_reader_ref ~ transition_writer_ref ~ frontier_w ~ precomputed_values new_frontier )
|
let download_best_tip ~ notify_online ~ logger ~ network ~ verifier ~ trust_system ~ most_recent_valid_block_writer ~ genesis_constants ~ precomputed_values = let num_peers = 16 in let % bind peers = Mina_networking . random_peers network num_peers in [ % log info ] info " Requesting peers for their best tip to do initialization " ; let % bind tips = Deferred . List . filter_map ~ how ` : Parallel peers ~ f ( : fun peer -> let open Deferred . Let_syntax in match % bind Mina_networking . get_best_tip ~ heartbeat_timeout ( : Time_ns . Span . of_min 1 ) . ~ timeout ( : Time . Span . of_min 1 ) . network peer with | Error e -> [ % log debug ] debug ~ metadata : [ ( " peer " , Network_peer . Peer . to_yojson peer ) peer ; ( " error " , Error_json . error_to_yojson e ) e ] " Couldn ' t get best tip from peer : $ error " ; return None | Ok peer_best_tip -> ( [ % log debug ] debug ~ metadata : [ ( " peer " , Network_peer . Peer . to_yojson peer ) peer ; ( " length " , Length . to_yojson ( Mina_block . blockchain_length peer_best_tip . data ) data ) ] " Successfully downloaded best tip with $ length from $ peer " ; match % bind Best_tip_prover . verify ~ verifier peer_best_tip ~ genesis_constants ~ precomputed_values with | Error e -> [ % log warn ] warn ~ metadata : [ ( " peer " , Network_peer . Peer . to_yojson peer ) peer ; ( " error " , Error_json . error_to_yojson e ) e ] " Peer sent us bad proof for their best tip " ; let % map ( ) = Trust_system ( . record trust_system logger peer Actions . ( Violated_protocol , Some ( " Peer sent us bad proof for their best tip " , [ ] ) ) ) in None | Ok ( ` Root _ , ` Best_tip candidate_best_tip ) candidate_best_tip -> [ % log debug ] debug ~ metadata [ : ( " peer " , Network_peer . Peer . to_yojson peer ) peer ] " Successfully verified best tip from $ peer " ; return ( Some ( Envelope . Incoming . wrap_peer ~ data { : peer_best_tip with data = candidate_best_tip } ~ sender : peer ) ) ) ) in [ % log debug ] debug ~ metadata : [ ( " actual " , ` Int ( List . length tips ) tips ) tips ; ( " expected " , ` Int num_peers ) num_peers ] " Finished requesting tips . Got $ actual / $ expected " ; let % map ( ) = notify_online ( ) in let res = List . fold tips ~ init : None ~ f ( : fun acc enveloped_candidate_best_tip -> Option . merge acc ( Option . return enveloped_candidate_best_tip ) enveloped_candidate_best_tip ~ f ( : fun enveloped_existing_best_tip enveloped_candidate_best_tip -> let f x = Validation . block_with_hash x |> With_hash . map ~ f : Mina_block . consensus_state in match Consensus . Hooks . select ~ constants : precomputed_values . consensus_constants ~ existing ( : f enveloped_existing_best_tip . data . data ) data ~ candidate ( : f enveloped_candidate_best_tip . data . data ) data ~ logger with | ` Keep -> enveloped_existing_best_tip | ` Take -> enveloped_candidate_best_tip ) ) in Option . iter res ~ f ( : fun best -> let best_tip_length = Validation . block best . data . data |> Mina_block . blockchain_length |> Length . to_int in Mina_metrics . Transition_frontier . update_max_blocklength_observed best_tip_length ; don ' t_wait_for @@ Broadcast_pipe . Writer . write most_recent_valid_block_writer best . data . data ) ; Option . map res ~ f : ( Envelope . Incoming . map ~ f ( : fun ( x : _ Proof_carrying_data . t ) t -> Ledger_catchup . Best_tip_lru . add x ; x . data ) )
|
let load_frontier ~ logger ~ verifier ~ persistent_frontier ~ persistent_root ~ consensus_local_state ~ precomputed_values ~ catchup_mode = match % map Transition_frontier . load ~ logger ~ verifier ~ consensus_local_state ~ persistent_root ~ persistent_frontier ~ precomputed_values ~ catchup_mode ( ) with | Ok frontier -> [ % log info ] info " Successfully loaded frontier " ; Some frontier | Error ` Persistent_frontier_malformed -> failwith " persistent frontier unexpectedly malformed -- this should not happen \ with retry enabled " | Error ` Bootstrap_required -> [ % log warn ] warn " Fast forward has not been implemented . Bootstrapping instead . " ; None | Error ( ` Failure e ) e -> failwith ( " failed to initialize transition frontier : " ^ e ) e | Error ` Snarked_ledger_mismatch -> [ % log warn ] warn " Persistent database is out of sync with snarked_ledger " ; None
|
let wait_for_high_connectivity ~ logger ~ network ~ is_seed = let connectivity_time_upperbound = 60 . 0 in let high_connectivity = Mina_networking . on_first_high_connectivity network ~ f : Fn . id in Deferred . any [ ( high_connectivity >>| fun ( ) -> [ % log info ] info " Already connected to enough peers , start initialization " ) ; ( after ( Time_ns . Span . of_sec connectivity_time_upperbound ) connectivity_time_upperbound >>= fun ( ) -> Mina_networking . peers network >>| fun peers -> if not @@ Deferred . is_determined high_connectivity then if List . length peers = 0 then if is_seed then [ % log info ] info ~ metadata : [ ( " max seconds to wait for high connectivity " , ` Float connectivity_time_upperbound ) ] " Will start initialization without connecting to any peers " else ( [ % log error ] error " Failed to find any peers during initialization ( crashing \ because this is not a seed node ) node " ; exit 1 ) else [ % log info ] info ~ metadata : [ ( " num peers " , ` Int ( List . length peers ) peers ) peers ; ( " max seconds to wait for high connectivity " , ` Float connectivity_time_upperbound ) ] " Will start initialization without connecting to too many peers " ) ]
|
let initialize ~ logger ~ network ~ is_seed ~ is_demo_mode ~ verifier ~ trust_system ~ time_controller ~ frontier_w ~ producer_transition_reader_ref ~ producer_transition_writer_ref ~ clear_reader ~ verified_transition_writer ~ transition_reader_ref ~ transition_writer_ref ~ most_recent_valid_block_writer ~ persistent_root ~ persistent_frontier ~ consensus_local_state ~ precomputed_values ~ catchup_mode ~ notify_online = let % bind ( ) = if is_demo_mode then return ( ) else wait_for_high_connectivity ~ logger ~ network ~ is_seed in let genesis_constants = Precomputed_values . genesis_constants precomputed_values in match % bind Deferred . both ( download_best_tip ~ notify_online ~ logger ~ network ~ verifier ~ trust_system ~ most_recent_valid_block_writer ~ genesis_constants ~ precomputed_values ) ( load_frontier ~ logger ~ verifier ~ persistent_frontier ~ persistent_root ~ consensus_local_state ~ precomputed_values ~ catchup_mode ) with | best_tip , None -> [ % log info ] info " Unable to load frontier ; starting bootstrap " ; let % map initial_root_transition = Persistent_frontier ( . with_instance_exn persistent_frontier ~ f : Instance . get_root_transition ) get_root_transition >>| Result . ok_or_failwith in start_bootstrap_controller ~ logger ~ trust_system ~ verifier ~ network ~ time_controller ~ producer_transition_reader_ref ~ producer_transition_writer_ref ~ verified_transition_writer ~ clear_reader ~ transition_reader_ref ~ consensus_local_state ~ transition_writer_ref ~ frontier_w ~ persistent_root ~ persistent_frontier ~ initial_root_transition ~ catchup_mode ~ best_seen_transition : best_tip ~ precomputed_values | best_tip , Some frontier -> ( match best_tip with | Some best_tip when is_transition_for_bootstrap ~ logger frontier ( best_tip |> Envelope . Incoming . data ) data ~ precomputed_values -> [ % log info ] info ~ metadata : [ ( " length " , ` Int ( Unsigned . UInt32 . to_int ( Mina_block . blockchain_length @@ Validation . block best_tip . data ) ) ) ] " Network best tip is too new to catchup to ( best_tip with \ $ length ) length ; starting bootstrap " ; let initial_root_transition = Transition_frontier ( . Breadcrumb . validated_transition ( root frontier ) frontier ) frontier in let % map ( ) = Transition_frontier . close ~ loc : __LOC__ frontier in start_bootstrap_controller ~ logger ~ trust_system ~ verifier ~ network ~ time_controller ~ producer_transition_reader_ref ~ producer_transition_writer_ref ~ verified_transition_writer ~ clear_reader ~ transition_reader_ref ~ consensus_local_state ~ transition_writer_ref ~ frontier_w ~ persistent_root ~ persistent_frontier ~ initial_root_transition ~ catchup_mode ~ best_seen_transition ( : Some best_tip ) best_tip ~ precomputed_values | _ -> if Option . is_some best_tip then [ % log info ] info ~ metadata : [ ( " length " , ` Int ( Unsigned . UInt32 . to_int ( Mina_block . blockchain_length @@ Validation . block ( Option . value_exn best_tip ) best_tip . data ) ) ) ] " Network best tip is recent enough to catchup to ( best_tip with \ $ length ) length ; syncing local state and starting participation " else [ % log info ] info " Successfully loaded frontier , but failed downloaded best tip \ from network " ; let curr_best_tip = Transition_frontier . best_tip frontier in let % map ( ) = match Consensus . Hooks . required_local_state_sync ~ constants : precomputed_values . consensus_constants ~ consensus_state : ( Transition_frontier . Breadcrumb . consensus_state curr_best_tip ) curr_best_tip ~ local_state : consensus_local_state with | None -> [ % log info ] info " Local state already in sync " ; Deferred . unit | Some sync_jobs -> ( [ % log info ] info " Local state is out of sync ; " ; match % map Consensus . Hooks . sync_local_state ~ local_state : consensus_local_state ~ logger ~ trust_system ~ random_peers ( : Mina_networking . random_peers network ) network ~ query_peer : { Consensus . Hooks . Rpcs . query = ( fun peer rpc query -> Mina_networking ( . query_peer network peer . peer_id ( Rpcs . Consensus_rpc rpc ) rpc query ) query ) } ~ ledger_depth : precomputed_values . constraint_constants . ledger_depth sync_jobs with | Error e -> Error . tag e ~ tag " : Local state sync failed " |> Error . raise | Ok ( ) -> ( ) ) in let collected_transitions = Option . to_list best_tip in start_transition_frontier_controller ~ logger ~ trust_system ~ verifier ~ network ~ time_controller ~ producer_transition_reader_ref ~ producer_transition_writer_ref ~ verified_transition_writer ~ clear_reader ~ collected_transitions ~ transition_reader_ref ~ transition_writer_ref ~ frontier_w ~ precomputed_values frontier )
|
let wait_till_genesis ~ logger ~ time_controller ( ~ precomputed_values : Precomputed_values . t ) t = let module Time = Block_time in let now = Time . now time_controller in let consensus_constants = precomputed_values . consensus_constants in let genesis_state_timestamp = consensus_constants . genesis_state_timestamp in try Consensus . Hooks . is_genesis_epoch ~ constants : consensus_constants now |> Fn . const Deferred . unit with Invalid_argument _ -> let time_till_genesis = Time . diff genesis_state_timestamp now in [ % log warn ] warn ~ metadata : [ ( " time_till_genesis " , ` Int ( Int64 . to_int_exn ( Time . Span . to_ms time_till_genesis ) time_till_genesis ) time_till_genesis ) ] " Node started before the chain start time : waiting $ time_till_genesis \ milliseconds before starting participation " ; let rec logger_loop ( ) = let % bind ( ) = after ( Time_ns . Span . of_sec 30 ) . in let now = Time . now time_controller in try Consensus . Hooks . is_genesis_epoch ~ constants : consensus_constants now |> Fn . const Deferred . unit with Invalid_argument _ -> let tm_remaining = Time . diff genesis_state_timestamp now in [ % log debug ] debug " Time before the chain start time . Waiting $ tm_remaining \ milliseconds before starting participation " ~ metadata : [ ( " tm_remaining " , ` Int ( Int64 . to_int_exn @@ Time . Span . to_ms tm_remaining ) tm_remaining ) ] ; logger_loop ( ) in Time . Timeout . await ~ timeout_duration : time_till_genesis time_controller ( logger_loop ( ) ) |> Deferred . ignore_m
|
let run ~ logger ~ trust_system ~ verifier ~ network ~ is_seed ~ is_demo_mode ~ time_controller ~ consensus_local_state ~ persistent_root_location ~ persistent_frontier_location ~ frontier_broadcast_pipe ( : frontier_r , frontier_w ) frontier_w ~ network_transition_reader ~ producer_transition_reader ~ most_recent_valid_block : ( most_recent_valid_block_reader , most_recent_valid_block_writer ) most_recent_valid_block_writer ~ precomputed_values ~ catchup_mode ~ notify_online = let initialization_finish_signal = Ivar . create ( ) in let clear_reader , clear_writer = Strict_pipe . create ~ name " : clear " Synchronous in let verified_transition_reader , verified_transition_writer = let name = " verified transitions " in create_bufferred_pipe ~ name ~ f ( : fun ( ` Transition ( head : Mina_block . Validated . t ) t , _ , ` Valid_cb valid_cb ) -> Mina_metrics ( . Counter . inc_one Pipe . Drop_on_overflow . router_verified_transitions ) router_verified_transitions ; Mina_block . handle_dropped_transition ( Mina_block . Validated . forget head |> With_hash . hash ) hash ~ pipe_name : name ~ logger ? valid_cb ) ( ) in let transition_reader , transition_writer = let name = " transition pipe " in create_bufferred_pipe ~ name ~ f ( : fun ( ` Block block , ` Valid_cb valid_cb ) valid_cb -> Mina_metrics ( . Counter . inc_one Pipe . Drop_on_overflow . router_transitions ) router_transitions ; Mina_block . handle_dropped_transition ( Network_peer . Envelope . Incoming . data block |> Validation . block_with_hash |> With_hash . hash ) ? valid_cb ~ pipe_name : name ~ logger ) ( ) in let transition_reader_ref = ref transition_reader in let transition_writer_ref = ref transition_writer in let producer_transition_reader_ref , producer_transition_writer_ref = let reader , writer = Strict_pipe . create ~ name " : producer transition " Synchronous in ( ref reader , ref writer ) writer in O1trace . background_thread " transition_router " ( fun ( ) -> don ' t_wait_for @@ Strict_pipe . Reader . iter producer_transition_reader ~ f ( : fun x -> Strict_pipe . Writer . write ! producer_transition_writer_ref x ) ; let % bind ( ) = wait_till_genesis ~ logger ~ time_controller ~ precomputed_values in let valid_transition_reader , valid_transition_writer = let name = " valid transitions " in create_bufferred_pipe ~ name ~ f ( : fun head -> let ` Block block , ` Valid_cb valid_cb = head in Mina_metrics ( . Counter . inc_one Pipe . Drop_on_overflow . router_valid_transitions ) router_valid_transitions ; Mina_block . handle_dropped_transition ( Network_peer . Envelope . Incoming . data block |> Validation . block_with_hash |> With_hash . hash ) ~ valid_cb ~ pipe_name : name ~ logger ) ( ) in Initial_validator . run ~ logger ~ trust_system ~ verifier ~ transition_reader : network_transition_reader ~ valid_transition_writer ~ initialization_finish_signal ~ precomputed_values ; let persistent_frontier = Transition_frontier . Persistent_frontier . create ~ logger ~ verifier ~ time_controller ~ directory : persistent_frontier_location in let persistent_root = Transition_frontier . Persistent_root . create ~ logger ~ directory : persistent_root_location ~ ledger_depth ( : Precomputed_values . ledger_depth precomputed_values ) precomputed_values in let % map ( ) = initialize ~ logger ~ network ~ is_seed ~ is_demo_mode ~ verifier ~ trust_system ~ persistent_frontier ~ persistent_root ~ time_controller ~ frontier_w ~ producer_transition_reader_ref ~ catchup_mode ~ producer_transition_writer_ref ~ clear_reader ~ verified_transition_writer ~ transition_reader_ref ~ transition_writer_ref ~ most_recent_valid_block_writer ~ consensus_local_state ~ precomputed_values ~ notify_online in Ivar . fill_if_empty initialization_finish_signal ( ) ; let valid_transition_reader1 , valid_transition_reader2 = Strict_pipe . Reader . Fork . two valid_transition_reader in don ' t_wait_for @@ Strict_pipe . Reader . iter valid_transition_reader1 ~ f ( : fun ( ` Block enveloped_transition , _ ) _ -> let incoming_transition = Envelope . Incoming . data enveloped_transition in let current_transition = Broadcast_pipe . Reader . peek most_recent_valid_block_reader in if Consensus . Hooks . equal_select_status ` Take ( Consensus . Hooks . select ~ constants : precomputed_values . consensus_constants ~ existing : ( Validation . block_with_hash current_transition |> With_hash . map ~ f : Mina_block . consensus_state ) ~ candidate : ( Validation . block_with_hash incoming_transition |> With_hash . map ~ f : Mina_block . consensus_state ) ~ logger ) then Broadcast_pipe . Writer . write most_recent_valid_block_writer incoming_transition else Deferred . unit ) ; don ' t_wait_for @@ Strict_pipe . Reader . iter_without_pushback valid_transition_reader2 ~ f ( : fun ( ` Block enveloped_transition , ` Valid_cb vc ) vc -> don ' t_wait_for @@ let % map ( ) = let incoming_transition = Envelope . Incoming . data enveloped_transition in match Broadcast_pipe . Reader . peek frontier_r with | Some frontier -> if is_transition_for_bootstrap ~ logger frontier incoming_transition ~ precomputed_values then ( Strict_pipe . Writer . kill ! transition_writer_ref ; Strict_pipe . Writer . kill ! producer_transition_writer_ref ; let initial_root_transition = Transition_frontier ( . Breadcrumb . validated_transition ( root frontier ) frontier ) frontier in let % bind ( ) = Strict_pipe . Writer . write clear_writer ` Clear in let % map ( ) = Transition_frontier . close ~ loc : __LOC__ frontier in start_bootstrap_controller ~ logger ~ trust_system ~ verifier ~ network ~ time_controller ~ producer_transition_reader_ref ~ producer_transition_writer_ref ~ verified_transition_writer ~ clear_reader ~ transition_reader_ref ~ transition_writer_ref ~ consensus_local_state ~ frontier_w ~ persistent_root ~ persistent_frontier ~ initial_root_transition ~ best_seen_transition ( : Some enveloped_transition ) enveloped_transition ~ precomputed_values ~ catchup_mode ) else Deferred . unit | None -> Deferred . unit in Strict_pipe . Writer . write ! transition_writer_ref ( ` Block enveloped_transition , ` Valid_cb ( Some vc ) vc ) vc ) ) ; ( verified_transition_reader , initialization_finish_signal ) initialization_finish_signal
|
let app e_fun e_list = match e_list with | [ ] -> e_fun | _ -> Oapp ( e_fun , e_list )
|
let sequence inst1 inst2 = match inst1 , inst2 with | ( Osequence [ ] , inst ) | ( inst , Osequence [ ] ) -> inst | Osequence ( l1 ) , Osequence ( l2 ) -> Osequence ( l1 @ l2 ) | _ , Osequence ( l2 ) -> Osequence ( inst1 :: l2 ) | _ -> Osequence [ inst1 ; inst2 ]
|
let kind = function | Zelus . S | Zelus . A | Zelus . AD | Zelus . AS -> Ofun | Zelus . C | Zelus . D -> Onode | Zelus . P -> Onode
|
let rec type_expression { Zelus . desc = desc } = match desc with | Zelus . Etypevar ( s ) -> Otypevar ( s ) | Zelus . Etypeconstr ( ln , ty_list ) -> Otypeconstr ( ln , List . map type_expression ty_list ) | Zelus . Etypetuple ( ty_list ) -> Otypetuple ( List . map type_expression ty_list ) | Zelus . Etypevec ( ty , s ) -> Otypevec ( type_expression ty , size s ) | Zelus . Etypefun ( k , opt_name , ty_arg , ty_res ) -> Otypefun ( kind k , opt_name , type_expression ty_arg , type_expression ty_res ) match desc with | Zelus . Eabstract_type -> Oabstract_type | Zelus . Eabbrev ( ty ) -> Oabbrev ( type_expression ty ) | Zelus . Evariant_type ( constr_decl_list ) -> Ovariant_type ( List . map constr_decl constr_decl_list ) | Zelus . Erecord_type ( n_ty_list ) -> Orecord_type ( List . map ( fun ( n , ty ) -> ( n , type_expression ty ) ) n_ty_list ) match desc with | Econstr0decl ( n ) -> Oconstr0decl ( n ) | Econstr1decl ( n , ty_list ) -> Oconstr1decl ( n , List . map type_expression ty_list ) match desc with | Zelus . Sconst ( i ) -> Sconst ( i ) | Zelus . Sglobal ( ln ) -> Sglobal ( ln ) | Zelus . Sname ( n ) -> Sname ( n ) | Zelus . Sop ( op , s1 , s2 ) -> let operator = function Zelus . Splus -> Splus | Zelus . Sminus -> Sminus in Sop ( operator op , size s1 , size s2 )
|
let rec is_mutable { t_desc = desc } = match desc with | Tvec _ -> true | Tlink ( link ) -> is_mutable link | _ -> false
|
let type_expression_of_typ ty = let ty_exp = Interface . type_expression_of_typ ty in type_expression ty_exp
|
type env = entry Env . t and entry = { e_typ : Deftypes . typ ; e_sort : sort ; e_size : loop_path ; } and sort = | In of exp | Out of Zident . t * Deftypes . tsort and loop_path = Zident . t list
|
type code = { mem : mentry State . t ; init : Obc . inst ; instances : ientry State . t ; reset : Obc . inst ; step : inst ; }
|
let fprint ff ( env : entry Env . t ) = let fprint_entry ff { e_typ = ty ; e_sort = sort ; e_size = size } = Format . fprintf ff " [ { @ typ = % a ; , @ size = % a } ] " @ Zident . Env . fprint_t fprint_entry ff env
|
let empty_code = { mem = State . empty ; init = Osequence [ ] ;
|
let seq { mem = m1 ; init = i1 ; instances = j1 ; reset = r1 ; step = s1 } { mem = State . seq m1 m2 ; init = sequence i1 i2 ; instances = State . par j1 j2 ; reset = sequence r1 r2 ; step = sequence s1 s2 }
|
let entry_of n env = try Env . find n env with Not_found -> Zmisc . internal_error " Unbound variable " Printer . name n
|
let immediate = function | Deftypes . Eint ( i ) -> Oint ( i ) | Deftypes . Efloat ( f ) -> Ofloat ( f ) | Deftypes . Ebool ( b ) -> Obool ( b ) | Deftypes . Echar ( c ) -> Ochar ( c ) | Deftypes . Estring ( s ) -> Ostring ( s ) | Deftypes . Evoid -> Ovoid
|
let constant = function | Deftypes . Cimmediate ( i ) -> Oconst ( immediate i ) | Deftypes . Cglobal ( ln ) -> Oglobal ( ln )
|
let state is_read n k = match k with | None -> Oleft_state_name ( n ) | Some ( k ) -> match k with | Deftypes . Cont -> | Deftypes . Zero -> Oleft_state_primitive_access | Deftypes . Horizon | Deftypes . Period | Deftypes . Encore | Deftypes . Major -> Oleft_state_name ( n )
|
let rec index e = function [ ] -> e | ei :: ei_list -> Oaccess ( index e ei_list , Olocal ( ei ) )
|
let rec left_value_index lv = function | [ ] -> lv | ei :: ei_list -> Oleft_index ( left_value_index lv ei_list , Olocal ( ei ) )
|
let rec left_state_value_index lv = function | [ ] -> lv | ei :: ei_list -> Oleft_state_index ( left_state_value_index lv ei_list , Olocal ( ei ) )
|
let var { e_sort = sort ; e_typ = ty ; e_size = ei_list } = match sort with | In ( e ) -> index e ei_list | Out ( n , sort ) -> match sort with | Sstatic | Sval -> index ( Olocal ( n ) ) ei_list | Svar _ -> index ( Ovar ( is_mutable ty , n ) ) ei_list | Smem { m_kind = k } -> Ostate ( left_state_value_index ( state true n k ) ei_list )
|
let assign { e_sort = sort ; e_size = ei_list } e = match sort with | In _ -> assert false | Out ( n , sort ) -> match sort with | Sstatic | Sval -> assert false | Svar _ -> Oassign ( left_value_index ( Oleft_name n ) ei_list , e ) | Smem { m_kind = k } ->
|
let def { e_typ = ty ; e_sort = sort ; e_size = ei_list } e ( { step = s } as code ) = match sort with | In _ -> assert false | Out ( n , sort ) -> match sort with | Sstatic | Sval -> { code with step = Olet ( Ovarpat ( n , type_expression_of_typ ty ) , e , s ) } | Svar _ -> sequence | Smem { m_kind = k } ->
|
let der { e_sort = sort ; e_size = ei_list } e ( { step = s } as code ) = match sort with | In _ -> assert false | Out ( n , sort ) -> { code with step = e ) )
|
let ifthen r_e i_code s = sequence ( Oif ( r_e , i_code , None ) ) s
|
let for_loop direction ix e1 e2 i_body = match i_body with | Osequence [ ] -> Osequence [ ] | _ -> Ofor ( direction , ix , e1 , e2 , i_body )
|
let letpat p e ( { step = s } as code ) = { code with step = Olet ( p , e , s ) }
|
let rec letvar l s = match l with | [ ] -> s | ( n , is_mutable , ty , v_opt ) :: l -> Oletvar ( n , is_mutable , ty , v_opt , letvar l s )
|
let pluseq ( { e_sort = sort ; e_size = ei_list } as entry ) let ln = match sort with | In _ -> assert false | Out ( n , sort ) -> match sort with | Svar { v_combine = Some ( ln ) } | Smem { m_combine = Some ( ln ) } -> ln | _ -> Zmisc . internal_error " Unbound variable " Printer . name n in { code with step =
|
let out_of n env = let { e_typ = ty ; e_sort = sort ; e_size = ix_list } = entry_of n env in match sort with | In _ -> assert false | Out ( x , sort ) -> x , ty , sort , ix_list
|
let rec size_of_type = function | Tconst ( i ) -> Sconst ( i ) | Tglobal ( q ) -> Sglobal ( Lident . Modname ( q ) ) | Tname ( n ) -> Sname ( n ) | Top ( op , s1 , s2 ) -> let e1 = size_of_type s1 in let e2 = size_of_type s2 in match op with | Tplus -> Sop ( Splus , e1 , e2 ) | Tminus -> Sop ( Sminus , e1 , e2 )
|
let rec size { Zelus . desc = desc } = match desc with | Zelus . Sconst ( i ) -> Sconst ( i ) | Zelus . Sglobal ( ln ) -> Sglobal ( ln ) | Zelus . Sname n -> Sname ( n ) | Zelus . Sop ( op , s1 , s2 ) -> let s1 = size s1 in let s2 = size s2 in match op with | Zelus . Splus -> Sop ( Splus , s1 , s2 ) | Zelus . Sminus -> Sop ( Sminus , s1 , s2 )
|
let choose env ty = let tuple l = Otuple ( l ) in let efalse = Oconst ( Obool ( false ) ) in let echar0 = Oconst ( Ochar ( ' a ' ) ) in let ezero = Oconst ( Oint ( 42 ) ) in let efzero = Oconst ( Ofloat ( 42 . 0 ) ) in let estring0 = Oconst ( Ostring ( " aaaaaaa " ) ) in let evoid = Oconst ( Ovoid ) in let eany = Oconst ( Oany ) in let vec e s = Ovec ( e , s ) in let rec value_from_deftype id = try let { info = { type_desc = ty_c } } = Modules . find_type ( Lident . Modname ( id ) ) in match ty_c with | Variant_type ( g_list ) -> value_from_variant_list g_list | Abstract_type -> eany | Record_type ( l_list ) -> Orecord ( ( fun { qualid = qualid ; info = { label_res = ty } } -> ( Lident . Modname ( qualid ) , value ty ) ) l_list ) | Abbrev ( _ , ty ) -> value ty with | Not_found -> eany and value ty = match ty . t_desc with | Tvar -> eany | Tproduct ( ty_l ) -> tuple ( List . map value ty_l ) | Tfun _ -> eany | Tvec ( ty , s ) -> vec ( value ty ) ( size_of_type s ) | Tconstr ( id , _ , _ ) -> if id = Initial . int_ident then ezero else if id = Initial . bool_ident then efalse else if id = Initial . char_ident then echar0 else if id = Initial . float_ident then efzero else if id = Initial . string_ident then estring0 else if id = Initial . unit_ident then evoid else if id = Initial . zero_ident then efalse else value_from_deftype id | Tlink ( link ) -> value link and value_from_variant_list g_list = let rec findrec g_list = match g_list with | [ ] -> raise Not_found | { qualid = qualid ; info = { constr_arity = arity } } :: g_list -> if arity = 0 then Oconstr0 ( Lident . Modname ( qualid ) ) else findrec g_list in try findrec g_list with | Not_found -> let { qualid = qualid ; info = { constr_arg = ty_list } } = List . hd g_list in Oconstr1 ( Lident . Modname ( qualid ) , List . map value ty_list ) in Some ( value ty )
|
let default env ty v_opt = match v_opt with | None -> choose env ty | Some ( v ) -> Some ( constant v )
|
let append loop_path l_env env = let addrec n { t_sort = k ; t_typ = ty } ( env_acc , mem_acc , var_acc ) = match k with | Sstatic | Sval -> | Svar { v_default = v_opt } -> | Smem { m_kind = k_opt } -> Env . fold addrec l_env ( env , State . empty , [ ] )
|
let apply k env loop_path e e_list match k with | Deftypes . Tstatic _ | Deftypes . Tany | Deftypes . Tdiscrete ( false ) -> Oapp ( e , e_list ) , code | Deftypes . Tdiscrete ( true ) | Deftypes . Tcont | Deftypes . Tproba -> let se_list , arg = Zmisc . firsts e_list in let f_opt = match e with | Oglobal ( g ) -> Some ( g ) | _ -> None in let loop_path = List . map ( fun ix -> Olocal ( ix ) ) loop_path in let o = Zident . fresh " i " in let j_code = { i_name = o ; i_machine = e ; i_kind = k ; let reset_code = Omethodcall ( { met_machine = f_opt ; met_name = Oaux . reset ; let step_code = Omethodcall ( { met_machine = f_opt ; met_name = Oaux . step ; step_code , { code with instances = State . cons j_code j ;
|
let rec exp env loop_path code { Zelus . e_desc = desc } = match desc with | Zelus . Econst ( i ) -> Oconst ( immediate i ) , code | Zelus . Elocal ( n ) | Zelus . Elast ( n ) -> var ( entry_of n env ) , code | Zelus . Eglobal { lname = ln } -> Oglobal ( ln ) , code | Zelus . Econstr0 ( ln ) -> Oconstr0 ( ln ) , code | Zelus . Econstr1 ( ln , e_list ) -> let e_list , code = Zmisc . map_fold ( exp env loop_path ) code e_list in Oconstr1 ( ln , e_list ) , code | Zelus . Etuple ( e_list ) -> let e_list , code = Zmisc . map_fold ( exp env loop_path ) code e_list in Otuple ( e_list ) , code | Zelus . Erecord ( label_e_list ) -> let label_e_list , code = Zmisc . map_fold Orecord ( label_e_list ) , code | Zelus . Erecord_access ( e_record , longname ) -> let e_record , code = exp env loop_path code e_record in Orecord_access ( e_record , longname ) , code | Zelus . Erecord_with ( e_record , label_e_list ) -> let e_record , code = exp env loop_path code e_record in let label_e_list , code = Zmisc . map_fold Orecord_with ( e_record , label_e_list ) , code | Zelus . Etypeconstraint ( e , ty_exp ) -> let e , code = exp env loop_path code e in let ty_exp = type_expression ty_exp in Otypeconstraint ( e , ty_exp ) , code | Zelus . Eop ( Zelus . Eup , [ e ] ) -> let e = if ! Zmisc . zsign then Zaux . sgn e else e in exp env loop_path code e | Zelus . Eop ( Zelus . Ehorizon , [ e ] ) -> exp env loop_path code e | Zelus . Eop ( Zelus . Eifthenelse , [ e1 ; e2 ; e3 ] ) -> let e1 , code = exp env loop_path code e1 in let e2 , code = exp env loop_path code e2 in let e3 , code = exp env loop_path code e3 in Oifthenelse ( e1 , e2 , e3 ) , code | Zelus . Eop ( Zelus . Eaccess , [ e1 ; e2 ] ) -> let e1 , code = exp env loop_path code e1 in let e2 , code = exp env loop_path code e2 in Oaccess ( e1 , e2 ) , code | Zelus . Eop ( Zelus . Eupdate , [ e1 ; i ; e2 ] ) -> let _ , se = Ztypes . filter_vec e1 . Zelus . e_typ in let se = size_of_type se in let e1 , code = exp env loop_path code e1 in let i , code = exp env loop_path code i in let e2 , code = exp env loop_path code e2 in Oupdate ( se , e1 , i , e2 ) , code | Zelus . Eop ( Zelus . Eslice ( s1 , s2 ) , [ e ] ) -> let s1 = size s1 in let s2 = size s2 in let e , code = exp env loop_path code e in Oslice ( e , s1 , s2 ) , code | Zelus . Eop ( Zelus . Econcat , [ e1 ; e2 ] ) -> let _ , s1 = Ztypes . filter_vec e1 . Zelus . e_typ in let _ , s2 = Ztypes . filter_vec e2 . Zelus . e_typ in let s1 = size_of_type s1 in let s2 = size_of_type s2 in let e1 , code = exp env loop_path code e1 in let e2 , code = exp env loop_path code e2 in Oconcat ( e1 , s1 , e2 , s2 ) , code | Zelus . Eop ( Zelus . Eatomic , [ e ] ) -> exp env loop_path code e | Zelus . Elet _ | Zelus . Eseq _ | Zelus . Eperiod _ | Zelus . Eop _ | Zelus . Epresent _ | Zelus . Ematch _ | Zelus . Eblock _ -> assert false | Zelus . Eapp ( _ , e_fun , e_list ) -> let se_list , ne_list , ty_res = Ztypes . split_arguments e_fun . Zelus . e_typ e_list in let e_fun , code = exp env loop_path code e_fun in let se_list , code = Zmisc . map_fold ( exp env loop_path ) code se_list in let ne_list , code = Zmisc . map_fold ( exp env loop_path ) code ne_list in let e_fun = app e_fun se_list in match ne_list with | [ ] -> e_fun , code | _ -> let k = Ztypes . kind_of_funtype ty_res in match desc with | Zelus . Ewildpat -> Owildpat | Zelus . Econstpat ( im ) -> Oconstpat ( immediate im ) | Zelus . Econstr0pat ( c0 ) -> Oconstr0pat ( c0 ) | Zelus . Econstr1pat ( c1 , p_list ) -> Oconstr1pat ( c1 , List . map pattern p_list ) | Zelus . Etuplepat ( p_list ) -> Otuplepat ( List . map pattern p_list ) | Zelus . Evarpat ( n ) -> Ovarpat ( n , type_expression_of_typ ty ) | Zelus . Erecordpat ( label_pat_list ) -> Orecordpat ( List . map ( fun ( label , pat ) -> ( label , pattern pat ) ) | Zelus . Etypeconstraintpat ( p , ty ) -> Otypeconstraintpat ( pattern p , type_expression ty ) | Zelus . Ealiaspat ( p , n ) -> Oaliaspat ( pattern p , n ) | Zelus . Eorpat ( p1 , p2 ) -> Oorpat ( pattern p1 , pattern p2 )
|
let rec equation env loop_path { Zelus . eq_desc = desc } code = match desc with | Zelus . EQeq ( { Zelus . p_desc = Zelus . Evarpat ( n ) } , e ) -> let e , code = exp env loop_path code e in def ( entry_of n env ) e code | Zelus . EQeq ( p , e ) -> let e , code = exp env loop_path code e in letpat ( pattern p ) e code | Zelus . EQpluseq ( n , e ) -> let e , code = exp env loop_path code e in pluseq ( entry_of n env ) e code | Zelus . EQder ( n , e , None , [ ] ) -> let e , code = exp env loop_path code e in der ( entry_of n env ) e code | Zelus . EQmatch ( _ , e , p_h_list ) -> let e , code = exp env loop_path code e in let p_step_h_list , p_h_code = match_handlers env loop_path p_h_list in seq { p_h_code with step = Omatch ( e , p_step_h_list ) } code | Zelus . EQreset ( [ { Zelus . eq_desc = Zelus . EQinit ( x , e ) } ] , r_e ) when not ( Reset . static e ) -> let r_e , code = exp env loop_path code r_e in let e , ( { init = i_code } as e_code ) = exp env loop_path empty_code e in let { step = s } as code = seq e_code code in { code with step = ifthen r_e ( sequence ( assign ( entry_of x env ) e ) i_code ) s } | Zelus . EQreset ( eq_list , r_e ) -> let { init = i_code } = code in let { init = ri_code } as r_code = equation_list env loop_path eq_list { code with init = Osequence [ ] } in let r_e , r_code = exp env loop_path r_code r_e in let { step = s } as code = seq r_code { empty_code with init = i_code } in { code with step = ifthen r_e ri_code s } | Zelus . EQinit ( x , e ) -> let e_c , code = exp env loop_path code e in let x_e = assign ( entry_of x env ) e_c in if Reset . static e then seq { empty_code with init = x_e ; reset = x_e } code else seq { empty_code with step = x_e } code | Zelus . EQforall { Zelus . for_index = i_list ; Zelus . for_init = init_list ; let rec index code = function | [ ] -> let id = Zident . fresh " i " in | { Zelus . desc = desc } :: i_list -> let in_out ix ( env_acc , code ) { Zelus . desc = desc } = match desc with | Zelus . Einput ( x , ( { Zelus . e_typ = ty } as e ) ) -> | Zelus . Eoutput ( x , y ) -> | Zelus . Eindex ( i , { Zelus . e_typ = ty } , _ ) -> let array_of_instance size ( { i_size } as ientry ) = { ientry with i_size = size :: i_size } in let array_of_memory size ( { m_size } as mentry ) = { mentry with m_size = size :: m_size } in let init code { Zelus . desc = desc } = match desc with | Zelus . Einit_last ( x , e ) -> let ( ix , e1 , e2 ) , code = index code i_list in let env , code = List . fold_left ( in_out ix ) ( env , code ) i_list in let { mem = m_code ; init = i_code ; instances = j_code ; block env ( ix :: loop_path ) b_eq_list in let j_code = State . map let m_code = State . map let initialization_list , Zmisc . map_fold init code init_list in { mem = State . seq m_code m ; instances = State . seq j_code j ; init = sequence ( for_loop true ix e1 e2 i_code ) i ; reset = sequence ( for_loop true ix e1 e2 r_code ) r ; step = sequence ( Osequence initialization_list ) | Zelus . EQbefore ( before_eq_list ) -> equation_list env loop_path before_eq_list code | Zelus . EQand _ | Zelus . EQblock _ | Zelus . EQnext _ | Zelus . EQder _ | Zelus . EQemit _ | Zelus . EQautomaton _ | Zelus . EQpresent _ -> assert false List . fold_right ( fun eq code -> equation env loop_path eq code ) eq_list code let body code { Zelus . m_pat = p ; Zelus . m_body = b ; Zelus . m_env = m_env } = let env , mem_acc , var_acc = append loop_path m_env env in let { mem = m_code ; step = s_code } as b_code = block env loop_path b in { w_pat = pattern p ; w_body = letvar var_acc s_code } , seq code Zmisc . map_fold body empty_code p_h_list let env , mem_acc , var_acc = append loop_path l_env env in let e , code = exp env loop_path empty_code e in let eq_code = equation_list env loop_path eq_list { code with step = Oexp ( e ) } in add_mem_vars_to_code eq_code mem_acc var_acc let env , mem_acc , var_acc = append loop_path n_env env in let eq_code = equation_list env loop_path eq_list empty_code in add_mem_vars_to_code eq_code mem_acc var_acc { code with mem = State . seq mem_acc mem ; step = letvar var_acc step }
|
let machine n k pat_list { mem = m ; instances = j ; reset = r ; step = s } let k = Interface . kindtype k in match k with | Deftypes . Tstatic _ | Deftypes . Tany | Deftypes . Tdiscrete ( false ) -> Oletfun ( n , pat_list , s ) | Deftypes . Tdiscrete ( true ) | Deftypes . Tcont | Deftypes . Tproba -> let pat_list , p = Zmisc . firsts pat_list in let body = { ma_kind = k ; me_typ = Initial . typ_unit } ; me_typ = ty_res } ] } in Oletmachine ( n , body )
|
let expression env ( { Zelus . e_desc = desc } as e ) = match desc with | Zelus . Elet ( l , e_let ) -> local env empty_path l e_let | _ -> let e , code = exp env empty_path empty_code e in
|
let implementation { Zelus . desc = desc } = match desc with | Zelus . Eopen ( n ) -> Oopen ( n ) | Zelus . Etypedecl ( n , params , ty_decl ) -> Otypedecl ( [ n , params , type_of_type_decl ty_decl ] ) | Zelus . Econstdecl ( n , _ , e ) -> let { step = s } = expression Env . empty e in Oletvalue ( n , s ) | Zelus . Efundecl ( n , { Zelus . f_kind = k ; Zelus . f_args = pat_list ; let pat_list = List . map pattern pat_list in let env , mem_acc , var_acc = append empty_path f_env Env . empty in let code = expression env e in let code = add_mem_vars_to_code code mem_acc var_acc in machine n k pat_list code e . Zelus . e_typ
|
let implementation_list impl_list = Zmisc . iter implementation impl_list
|
type concrete_regexp = | Epsilon | Eof | Characters of Fcset . t | Sequence of concrete_regexp * concrete_regexp | Alternative of concrete_regexp * concrete_regexp | Repetition of concrete_regexp | Bind of concrete_regexp * ( Locf . t * string )
|
type ' a entry = { shortest : bool ; clauses : ( concrete_regexp * ' a ) list }
|
let regexp_for_string s = let rec re_string n = let len = String . length s in if n >= len then Epsilon else if n + 1 = len then Characters ( Fcset . singleton ( Char . code s . [ n ] ) ) else Sequence ( Characters ( Fcset . singleton ( Char . code s . [ n ] ) ) , re_string ( n + 1 ) ) in re_string 0
|
let rec remove_as x = match x with | Bind ( e , _ ) -> remove_as e | Epsilon | Eof | Characters _ as e -> e | Sequence ( e1 , e2 ) -> Sequence ( remove_as e1 , remove_as e2 ) | Alternative ( e1 , e2 ) -> Alternative ( remove_as e1 , remove_as e2 ) | Repetition e -> Repetition ( remove_as e )
|
let as_cset = function | Characters s -> s | _ -> raise Bad
|
let remove_nested_as e : concrete_regexp = let rec do_remove_nested ( to_remove : Id_set . t ) x : concrete_regexp = match x with | Bind ( e , x ) -> if Id_set . mem x to_remove then do_remove_nested to_remove e else Bind ( do_remove_nested ( Id_set . add x to_remove ) e , x ) | Epsilon | Eof | Characters _ as e -> e | Sequence ( e1 , e2 ) -> Sequence ( do_remove_nested to_remove e1 , do_remove_nested to_remove e2 ) | Alternative ( e1 , e2 ) -> Alternative ( do_remove_nested to_remove e1 , do_remove_nested to_remove e2 ) | Repetition e -> Repetition ( do_remove_nested to_remove e ) in do_remove_nested Id_set . empty e
|
let rec find_all_vars ( x : concrete_regexp ) : Id_set . t = let open Id_set in match x with | Characters _ | Epsilon | Eof -> empty | Bind ( e , x ) -> add x ( find_all_vars e ) | Sequence ( e1 , e2 ) | Alternative ( e1 , e2 ) -> union ( find_all_vars e1 ) ( find_all_vars e2 ) | Repetition e -> find_all_vars e
|
let find_optional e = let rec do_find_opt x : Id_set . t * Id_set . t = let open Id_set in match x with | Characters _ | Epsilon | Eof -> ( empty , empty ) | Bind ( e , x ) -> let ( opt , all ) = do_find_opt e in ( opt , add x all ) | Sequence ( e1 , e2 ) -> let ( opt1 , all1 ) = do_find_opt e1 and ( opt2 , all2 ) = do_find_opt e2 in ( union opt1 opt2 , union all1 all2 ) | Alternative ( e1 , e2 ) -> let ( opt1 , all1 ) = do_find_opt e1 and ( opt2 , all2 ) = do_find_opt e2 in ( union ( union opt1 opt2 ) ( union ( diff all1 all2 ) ( diff all2 all1 ) ) , union all1 all2 ) | Repetition e -> let r = find_all_vars e in ( r , r ) in fst @@ do_find_opt e
|
let rec do_find_double x : Id_set . t * Id_set . t = let open Id_set in match x with | Characters _ | Epsilon | Eof -> ( empty , empty ) | Bind ( e , x ) -> let ( dbl , all ) = do_find_double e in ( ( if mem x all then add x dbl else dbl ) , add x all ) | Sequence ( e1 , e2 ) -> let ( dbl1 , all1 ) = do_find_double e1 and ( dbl2 , all2 ) = do_find_double e2 in ( union ( inter all1 all2 ) ( union dbl1 dbl2 ) , union all1 all2 ) | Alternative ( e1 , e2 ) -> let ( dbl1 , all1 ) = do_find_double e1 and ( dbl2 , all2 ) = do_find_double e2 in ( union dbl1 dbl2 , union all1 all2 ) | Repetition e -> let r = find_all_vars e in ( r , r )
|
let find_double e = do_find_double e
|
let add_some x = function | Some i -> Some ( x + i ) | None -> None
|
let add_some_some x y = match x , y with | ( Some i , Some j ) -> Some ( i + j ) | ( _ , _ ) -> None
|
let find_chars e = let open Id_set in let rec do_find_chars ( sz : int option ) x = match x with | Epsilon | Eof -> ( empty , empty , sz ) | Characters _ -> ( empty , empty , add_some 1 sz ) | Bind ( e , x ) -> let ( c , s , e_sz ) = do_find_chars ( Some 0 ) e in begin match e_sz with | Some 1 -> ( add x c , s , add_some 1 sz ) | _ -> ( c , add x s , add_some_some sz e_sz ) end | Sequence ( e1 , e2 ) -> let ( c1 , s1 , sz1 ) = do_find_chars sz e1 in let ( c2 , s2 , sz2 ) = do_find_chars sz1 e2 in ( union c1 c2 , union s1 s2 , sz2 ) | Alternative ( e1 , e2 ) -> let ( c1 , s1 , sz1 ) = do_find_chars sz e1 and ( c2 , s2 , sz2 ) = do_find_chars sz e2 in ( union c1 c2 , union s1 s2 , if sz1 = sz2 then sz1 else None ) | Repetition e -> do_find_chars None e in let ( c , s , _ ) = do_find_chars ( Some 0 ) e in diff c s
|
let chars = ref ( [ ] : Fcset . t list )
|
let chars_count = ref 0
|
let rec encode_regexp ( char_vars : Id_set . t ) ( act : int ) x : regexp = match x with | Epsilon -> Empty | Characters cl -> let n = ! chars_count in begin chars := cl :: ! chars ; incr chars_count ; Chars ( n , false ) end | Eof -> let n = ! chars_count in begin chars := Fcset . eof :: ! chars ; incr chars_count ; Chars ( n , true ) end | Sequence ( r1 , r2 ) -> let r1 = encode_regexp char_vars act r1 in let r2 = encode_regexp char_vars act r2 in Seq ( r1 , r2 ) | Alternative ( r1 , r2 ) -> let r1 = encode_regexp char_vars act r1 in let r2 = encode_regexp char_vars act r2 in Alt ( r1 , r2 ) | Repetition r -> Star ( encode_regexp char_vars act r ) | Bind ( r , ( ( _ , name ) as y ) ) -> let r = encode_regexp char_vars act r in if Id_set . mem y char_vars then Seq ( Tag { id = name ; start = true ; action = act } , r ) else Seq ( Tag { id = name ; start = true ; action = act } , Seq ( r , Tag { id = name ; start = false ; action = act } ) )
|
let mk_seq ( r1 : regexp ) ( r2 : regexp ) : regexp = match r1 , r2 with | Empty , _ -> r2 | _ , Empty -> r1 | _ -> Seq ( r1 , r2 )
|
let add_pos p i = match ( p : Automata_def . tag_addr option ) with | Some ( a , n ) -> Some ( a , n + i ) | None -> None
|
let mem_name name ( id_set : Id_set . t ) : bool = Id_set . exists ( function ( _ , id_name ) -> name = id_name ) id_set
|
let rec size_forward pos ( x : regexp ) : int option = match x with | Empty | Chars ( _ , true ) | Tag _ -> Some pos | Chars ( _ , false ) -> Some ( pos + 1 ) | Seq ( r1 , r2 ) -> begin match size_forward pos r1 with | None -> None | Some pos -> size_forward pos r2 end | Alt ( r1 , r2 ) -> let pos1 = size_forward pos r1 and pos2 = size_forward pos r2 in if pos1 = pos2 then pos1 else None | Star _ -> None | Action _ -> assert false
|
let rec size_backward pos ( x : regexp ) = match x with | Empty | Chars ( _ , true ) | Tag _ -> Some pos | Chars ( _ , false ) -> Some ( pos - 1 ) | Seq ( r1 , r2 ) -> begin match size_backward pos r2 with | None -> None | Some pos -> size_backward pos r1 end | Alt ( r1 , r2 ) -> let pos1 = size_backward pos r1 and pos2 = size_backward pos r2 in if pos1 = pos2 then pos1 else None | Star _ -> None | Action _ -> assert false
|
let opt_regexp all_vars char_vars optional_vars double_vars ( r : regexp ) : ( Id_set . elt * ident_info ) list * regexp * int = let env = Hashtbl . create 17 in let rec simple_forward pos r double_vars = match r with | Tag n -> if mem_name n . id double_vars then ( r , Some pos ) else begin Hashtbl . add env ( n . id , n . start ) ( Start , pos ) ; ( Empty , Some pos ) end | Empty -> ( r , Some pos ) | Chars ( _ , is_eof ) -> ( r , Some ( if is_eof then pos else pos + 1 ) ) | Seq ( r1 , r2 ) -> begin match simple_forward pos r1 double_vars with | r1 , None -> ( mk_seq r1 r2 , None ) | r1 , Some pos -> let ( r2 , pos ) = simple_forward pos r2 double_vars in ( mk_seq r1 r2 , pos ) end | Alt ( r1 , r2 ) -> let pos1 = size_forward pos r1 and pos2 = size_forward pos r2 in ( r , if pos1 = pos2 then pos1 else None ) | Star _ -> ( r , None ) | Action _ -> assert false in let rec simple_backward pos r double_vars = match r with | Tag n -> if mem_name n . id double_vars then ( r , Some pos ) else begin Hashtbl . add env ( n . id , n . start ) ( End , pos ) ; ( Empty , Some pos ) end | Empty -> ( r , Some pos ) | Chars ( _ , is_eof ) -> ( r , Some ( if is_eof then pos else pos - 1 ) ) | Seq ( r1 , r2 ) -> begin match simple_backward pos r2 double_vars with | r2 , None -> ( mk_seq r1 r2 , None ) | r2 , Some pos -> let ( r1 , pos ) = simple_backward pos r1 double_vars in ( mk_seq r1 r2 , pos ) end | Alt ( r1 , r2 ) -> let pos1 = size_backward pos r1 and pos2 = size_backward pos r2 in ( r , if pos1 = pos2 then pos1 else None ) | Star _ -> ( r , None ) | Action _ -> assert false in let r = let r , _ = simple_forward 0 r double_vars in let r , _ = simple_backward 0 r double_vars in r in let loc_count = ref 0 in let get_tag_addr t = try Hashtbl . find env t with Not_found -> let n = ! loc_count in begin incr loc_count ; Hashtbl . add env t ( Mem n , 0 ) ; ( Mem n , 0 ) end in let rec alloc_exp pos r = match r with | Tag n -> if mem_name n . id double_vars then ( r , pos ) else begin match pos with | Some a -> begin Hashtbl . add env ( n . id , n . start ) a ; ( Empty , pos ) end | None -> let a = get_tag_addr ( n . id , n . start ) in ( r , Some a ) end | Empty -> ( r , pos ) | Chars ( _ , is_eof ) -> ( r , ( if is_eof then pos else add_pos pos 1 ) ) | Seq ( r1 , r2 ) -> let ( r1 , pos ) = alloc_exp pos r1 in let ( r2 , pos ) = alloc_exp pos r2 in ( mk_seq r1 r2 , pos ) | Alt ( _ , _ ) -> let off = size_forward 0 r in begin match off with | Some i -> ( r , add_pos pos i ) | None -> ( r , None ) end | Star _ -> ( r , None ) | Action _ -> assert false in let ( r , _ ) = alloc_exp None r in let m = Id_set . fold ( fun ( ( _ , name ) as x ) r -> let v = if Id_set . mem x char_vars then Ident_char ( Id_set . mem x optional_vars , get_tag_addr ( name , true ) ) else Ident_string ( Id_set . mem x optional_vars , get_tag_addr ( name , true ) , get_tag_addr ( name , false ) ) in ( x , v ) :: r ) all_vars [ ] in ( m , r , ! loc_count )
|
let encode_casedef ( regexps ( : concrete_regexp * ' a ) list ) = List . fold_left ( fun ( reg , actions , count , ntags ) ( expr , act ) -> let expr = remove_nested_as expr in let char_vars = find_chars expr in let opt_vars = find_optional expr in let ( double_vars , all_vars ) = find_double expr in let r = encode_regexp char_vars count expr in let ( m , r , loc_ntags ) = opt_regexp all_vars char_vars opt_vars double_vars r in ( Alt ( reg , Seq ( r , Action count ) ) , ( count , m , act ) :: actions , count + 1 , max loc_ntags ntags ) ) ( Empty , [ ] , 0 , 0 ) regexps
|
let reset ( ) = chars := [ ] ; chars_count := 0
|
type ' a lexer_entry = { lex_regexp : regexp ; lex_mem_tags : int ; lex_actions : ( int * t_env * ' a ) list }
|
let encode_lexdef ( def ' : a entry list ) : Fcset . t array * ( ' a lexer_entry * bool ) list = reset ( ) ; let entry_list = List . map ( fun { shortest ; clauses } -> let ( lex_regexp , actions , _ , lex_mem_tags ) = encode_casedef clauses in ( { lex_regexp ; lex_mem_tags ; lex_actions = List . rev actions } , shortest ) ) def in Array . of_list ( List . rev ! chars ) , entry_list
|
let encode_single_lexdef ( def ' : a entry ) : Fcset . t array * ( ' a lexer_entry * bool ) = reset ( ) ; let result = match def with { shortest ; clauses } -> let ( lex_regexp , actions , _ , lex_mem_tags ) = encode_casedef clauses in ( { lex_regexp ; lex_mem_tags ; lex_actions = List . rev actions } , shortest ) in Array . of_list ( List . rev ! chars ) , result
|
module Table = Map . Make ( String )
|
module Namespace = struct type t = string Table . t let empty : t = Table . empty let translate ~ ocaml ~ coq = Table . add ocaml coq let preserve ocaml = translate ~ ocaml ~ coq : ocaml let find ~ ocaml : from = Table . find_opt from end
|
type t = Namespace . t Table . t
|
let qualname prefix suffix = prefix ^ " . " ^ suffix
|
let rec translate ( ? rev_namespace = [ ] ) ~ ocaml ~ coq t = let prefix = String . concat " . " rev_namespace in let t = Table . update prefix ( fun ns -> Option . value ~ default : Namespace . empty ns |> Namespace . translate ~ ocaml ~ coq |> Option . some ) t in match rev_namespace with | [ ] -> t | x :: rev_namespace -> translate ~ rev_namespace ~ ocaml ( : qualname x ocaml ) ~ coq ( : qualname x coq ) t
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.