From 770acf01f85d21f3f58d0f8a3a8a17f8272e0722 Mon Sep 17 00:00:00 2001 From: David Chu Date: Sat, 20 Sep 2025 00:39:53 +0000 Subject: [PATCH 01/35] Bug fix part 2 --- hydro_optimize/src/parse_results.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hydro_optimize/src/parse_results.rs b/hydro_optimize/src/parse_results.rs index 2414104..2b0e557 100644 --- a/hydro_optimize/src/parse_results.rs +++ b/hydro_optimize/src/parse_results.rs @@ -316,7 +316,7 @@ pub fn get_or_append_run_metadata( multi_run_metadata: &mut MultiRunMetadata, iteration: usize, ) -> &mut RunMetadata { - if multi_run_metadata.len() <= iteration { + while multi_run_metadata.len() < iteration + 1 { multi_run_metadata.push(RunMetadata::default()); } multi_run_metadata.get_mut(iteration).unwrap() From e61aee6ade44bb1cc41564ba82a90f8f49fd41a9 Mon Sep 17 00:00:00 2001 From: David Chu Date: Sat, 20 Sep 2025 00:44:20 +0000 Subject: [PATCH 02/35] Migrate toy_examples from main repo --- .gitignore | 4 +- Cargo.lock | 5 + hydro_optimize_examples/Cargo.toml | 10 +- .../examples/simple_graphs.rs | 130 +++ hydro_optimize_examples/src/lib.rs | 7 + hydro_optimize_examples/src/lobsters.rs | 165 +++ hydro_optimize_examples/src/lock_server.rs | 80 ++ hydro_optimize_examples/src/simple_graphs.rs | 1021 +++++++++++++++++ .../src/simple_graphs_bench.rs | 33 + .../src/simple_kv_bench.rs | 140 +++ hydro_optimize_examples/src/web_submit.rs | 404 +++++++ 11 files changed, 1995 insertions(+), 4 deletions(-) create mode 100644 hydro_optimize_examples/examples/simple_graphs.rs create mode 100644 hydro_optimize_examples/src/lobsters.rs create mode 100644 hydro_optimize_examples/src/lock_server.rs create mode 100644 hydro_optimize_examples/src/simple_graphs.rs create mode 100644 hydro_optimize_examples/src/simple_graphs_bench.rs create mode 100644 hydro_optimize_examples/src/simple_kv_bench.rs create mode 100644 hydro_optimize_examples/src/web_submit.rs diff --git a/.gitignore b/.gitignore index 308a2f7..98d6e30 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,3 @@ target/ -.data.folded -.perf.data \ No newline at end of file +*.data.folded +*.perf.data \ No newline at end of file diff --git a/Cargo.lock b/Cargo.lock index aa58c21..45112e3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1830,11 +1830,16 @@ version = "0.0.0" dependencies = [ "clap", "ctor 0.2.9", + "dfir_lang", + "hydro_build_utils", "hydro_deploy", "hydro_lang", "hydro_optimize", "hydro_std", "hydro_test", + "regex", + "serde", + "sha2", "stageleft", "stageleft_tool", "tokio", diff --git a/hydro_optimize_examples/Cargo.toml b/hydro_optimize_examples/Cargo.toml index c1da3ad..32792ed 100644 --- a/hydro_optimize_examples/Cargo.toml +++ b/hydro_optimize_examples/Cargo.toml @@ -11,15 +11,21 @@ all-features = true hydro_lang = { git = "https://github.com/hydro-project/hydro.git" } hydro_std = { git = "https://github.com/hydro-project/hydro.git" } hydro_test = { git = "https://github.com/hydro-project/hydro.git" } +serde = { version = "1.0.197", features = ["derive"] } +sha2 = "0.10.9" stageleft = "0.9.7" tokio = { version = "1.29.0", features = ["full"] } [dev-dependencies] ctor = "0.2" clap = { version = "4.4", features = ["derive"] } +dfir_lang = { git = "https://github.com/hydro-project/hydro.git" } +hydro_build_utils = { git = "https://github.com/hydro-project/hydro.git", version = "0.0.1" } hydro_deploy = { git = "https://github.com/hydro-project/hydro.git" } -hydro_lang = { git = "https://github.com/hydro-project/hydro.git", features = ["deploy"] } +hydro_lang = { git = "https://github.com/hydro-project/hydro.git", features = ["deploy", "viz"] } hydro_optimize = { path = "../hydro_optimize" } +regex = "1.11.1" [build-dependencies] -stageleft_tool = "0.9.7" \ No newline at end of file +stageleft_tool = "0.9.7" +hydro_build_utils = { git = "https://github.com/hydro-project/hydro.git", version = "0.0.1" } \ No newline at end of file diff --git a/hydro_optimize_examples/examples/simple_graphs.rs b/hydro_optimize_examples/examples/simple_graphs.rs new file mode 100644 index 0000000..eb62392 --- /dev/null +++ b/hydro_optimize_examples/examples/simple_graphs.rs @@ -0,0 +1,130 @@ +use std::cell::RefCell; +use std::collections::HashMap; +use std::sync::Arc; + +use clap::Parser; +use hydro_deploy::Deployment; +use hydro_deploy::gcp::GcpNetwork; +use hydro_lang::graph::config::GraphConfig; +use hydro_lang::location::Location; +use hydro_lang::prelude::FlowBuilder; +use hydro_optimize::decoupler; +use hydro_optimize::deploy::ReusableHosts; +use hydro_optimize::deploy_and_analyze::deploy_and_analyze; +use hydro_optimize_examples::simple_graphs::{Client, Server, get_graph_function}; +use hydro_optimize_examples::simple_graphs_bench::{Aggregator, simple_graphs_bench}; +use tokio::sync::RwLock; + +#[derive(Parser, Debug)] +#[command(author, version, about, long_about = None)] +struct Args { + #[command(flatten)] + graph: GraphConfig, + + /// Use GCP for deployment (provide project name) + #[arg(long)] + gcp: Option, + + #[arg(long)] + function: String, +} + +#[tokio::main] +async fn main() { + let args = Args::parse(); + + let mut deployment = Deployment::new(); + let (host_arg, project) = if let Some(project) = args.gcp { + ("gcp".to_string(), project) + } else { + ("localhost".to_string(), String::new()) + }; + let network = Arc::new(RwLock::new(GcpNetwork::new(&project, None))); + + let mut builder = FlowBuilder::new(); + let num_clients = 10; + let num_clients_per_node = 1000; + let graph_function = get_graph_function(&args.function); + let server = builder.cluster(); + let clients = builder.cluster(); + let client_aggregator = builder.process(); + + simple_graphs_bench( + num_clients_per_node, + &server, + &clients, + &client_aggregator, + graph_function, + ); + + let mut clusters = vec![ + ( + server.id().raw_id(), + std::any::type_name::().to_string(), + 1, + ), + ( + clients.id().raw_id(), + std::any::type_name::().to_string(), + num_clients, + ), + ]; + let processes = vec![( + client_aggregator.id().raw_id(), + std::any::type_name::().to_string(), + )]; + + // Deploy + let mut reusable_hosts = ReusableHosts { + hosts: HashMap::new(), + host_arg, + project: project.clone(), + network: network.clone(), + }; + + let num_times_to_optimize = 2; + let num_seconds_to_profile = Some(20); + let multi_run_metadata = RefCell::new(vec![]); + + for i in 0..num_times_to_optimize { + let (rewritten_ir_builder, mut ir, mut decoupler, bottleneck_name, bottleneck_num_nodes) = + deploy_and_analyze( + &mut reusable_hosts, + &mut deployment, + builder, + &clusters, + &processes, + vec![ + std::any::type_name::().to_string(), + std::any::type_name::().to_string(), + ], + num_seconds_to_profile, + &multi_run_metadata, + i, + ) + .await; + + // Apply decoupling + let mut decoupled_cluster = None; + builder = rewritten_ir_builder.build_with(|builder| { + let new_cluster = builder.cluster::<()>(); + decoupler.decoupled_location = new_cluster.id().clone(); + decoupler::decouple(&mut ir, &decoupler, &multi_run_metadata, i); + decoupled_cluster = Some(new_cluster); + + ir + }); + if let Some(new_cluster) = decoupled_cluster { + clusters.push(( + new_cluster.id().raw_id(), + format!("{}_decouple_{}", bottleneck_name, i), + bottleneck_num_nodes, + )); + } + } + + let built = builder.finalize(); + + // Generate graphs if requested + _ = built.generate_graph_with_config(&args.graph, None); +} \ No newline at end of file diff --git a/hydro_optimize_examples/src/lib.rs b/hydro_optimize_examples/src/lib.rs index 09bf34a..9617274 100644 --- a/hydro_optimize_examples/src/lib.rs +++ b/hydro_optimize_examples/src/lib.rs @@ -1,5 +1,12 @@ stageleft::stageleft_no_entry_crate!(); +pub mod simple_graphs; +pub mod simple_graphs_bench; +pub mod simple_kv_bench; +pub mod lock_server; +pub mod lobsters; +pub mod web_submit; + #[cfg(test)] mod test_init { #[ctor::ctor] diff --git a/hydro_optimize_examples/src/lobsters.rs b/hydro_optimize_examples/src/lobsters.rs new file mode 100644 index 0000000..7d1546e --- /dev/null +++ b/hydro_optimize_examples/src/lobsters.rs @@ -0,0 +1,165 @@ +use std::collections::HashSet; + +use hydro_lang::{ + live_collections::stream::NoOrder, + location::{Location, MemberId}, + nondet::nondet, + prelude::{Process, Stream, Unbounded}, +}; +use sha2::{Digest, Sha256}; +use stageleft::q; +use serde::{Deserialize, Serialize}; +use tokio::time::Instant; + +pub struct Server {} + +#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)] +pub struct Story { + pub title: String, + pub epoch_time: u128, + pub id: u32, +} + +impl PartialOrd for Story { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.epoch_time.cmp(&other.epoch_time)) + } +} + +/// Implementation of Lobsters, roughly based on API calls exposed here: https://lobste.rs/s/cqnzl5/lobste_rs_access_pattern_statistics_for#c_2op8by +/// We expose the following APIs: +/// - add_user (takes username, returns api_key, should only approve if user is admin but it's tautological so just approve everyone) +/// - get_users (returns usernames) +/// - add_story (takes api_key, title, timestamp, returns story_id) +/// - add_comment (takes api_key, story_id, comment, timestamp, returns comment_id) +/// - upvote_story (takes api_key, story_id) +/// - upvote_comment (takes api_key, comment_id) +/// - get_stories (returns the 20 stories with the latest timestamps) +/// - get_comments (returns the 20 comments with the latest timestamps) +/// - get_story_comments (takes story_id, returns the comments for that story) +/// +/// Any call with an invalid API key (either it does not exist or does not have the privileges required) will not receive a response. +#[expect( + clippy::too_many_arguments, + clippy::type_complexity, + reason = "internal Lobsters code // TODO" +)] +pub fn lobsters<'a, Client>( + server: &Process<'a, Server>, + add_user: Stream<(MemberId, String), Process<'a, Server>, Unbounded, NoOrder>, + get_users: Stream, Process<'a, Server>, Unbounded, NoOrder>, + add_story: Stream< + (MemberId, (String, String, Instant)), + Process<'a, Server>, + Unbounded, + NoOrder, + >, + _add_comment: Stream< + (MemberId, (String, u32, String, Instant)), + Process<'a, Server>, + Unbounded, + NoOrder, + >, + _upvote_story: Stream< + (MemberId, (String, u32)), + Process<'a, Server>, + Unbounded, + NoOrder, + >, + _upvote_comment: Stream< + (MemberId, (String, u32)), + Process<'a, Server>, + Unbounded, + NoOrder, + >, + _get_stories: Stream, Process<'a, Server>, Unbounded, NoOrder>, + _get_comments: Stream, Process<'a, Server>, Unbounded, NoOrder>, + _get_story_comments: Stream<(MemberId, u32), Process<'a, Server>, Unbounded, NoOrder>, +) { + let user_auth_tick = server.tick(); + let stories_tick = server.tick(); + + // Add user + let add_user_with_api_key = add_user.map(q!(|(client_id, username)| { + let api_key = self::generate_api_key(username.clone()); + (client_id, (username, api_key)) + })); + let users_this_tick_with_api_key = add_user_with_api_key.batch( + &user_auth_tick, + nondet!(/** Snapshot current users to approve/deny access */), + ); + // Persisted users + let curr_users = users_this_tick_with_api_key + .clone() + .map(q!(|(_client_id, (username, api_key))| (api_key, username))) + .persist(); + let curr_users_hashset = curr_users.clone().fold_commutative_idempotent( + q!(|| HashSet::new()), + q!(|set, (_api_key, username)| { + set.insert(username); + }), + ); + // Send response back to client. Only done after the tick to ensure that once the client gets the response, the user has been added + let _add_user_response = + users_this_tick_with_api_key + .all_ticks() + .map(q!(|(client_id, (_api_key, _username))| (client_id, ()))); + + // Get users + let _get_users_response = get_users + .batch( + &user_auth_tick, + nondet!(/** Snapshot against current users */), + ) + .cross_singleton(curr_users_hashset) + .all_ticks(); + + // Add story + let add_story_pre_join = add_story.map(q!(|(client_id, (api_key, title, timestamp))| { + (api_key, (client_id, title, timestamp)) + })); + let stories = add_story_pre_join + .batch( + &user_auth_tick, + nondet!(/** Compare against current users to approve/deny access */), + ) + .join(curr_users.clone()) + .all_ticks(); + let curr_stories = stories.batch(&stories_tick, nondet!(/** Snapshot of current stories */)).assume_ordering(nondet!(/** In order to use enumerate to assign a unique ID, we need total ordering. */)); + // Assign each story a unique ID + let (story_id_complete_cycle, story_id) = + stories_tick.cycle_with_initial(stories_tick.singleton(q!(0))); + let _indexed_curr_stories = curr_stories + .clone() + .enumerate() + .cross_singleton(story_id.clone()) + .map(q!(|((index, story), story_id)| (index + story_id, story))); + let num_curr_stories = curr_stories.clone().count(); + let new_story_id = num_curr_stories + .zip(story_id) + .map(q!(|(num_stories, story_id)| num_stories + story_id)); + story_id_complete_cycle.complete_next_tick(new_story_id); + + let _top_stories = curr_stories.clone().persist().fold_commutative_idempotent( + q!(|| vec![]), + q!( + |vec, (_api_key, ((_client_id, title, timestamp), username))| { + let new_elem = (title, timestamp, username); + // TODO: Use a binary heap + // TODO: Create a struct that is ordered by timestamp + let pos = vec.binary_search(&new_elem).unwrap_or_else(|e| e); + vec.insert(pos, new_elem); + vec.truncate(20); + } + ), + ); +} + +fn generate_api_key(email: String) -> String { + let secret = "There is no secret ingredient"; + let mut hasher = Sha256::new(); + hasher.update(email.as_bytes()); + hasher.update(secret.as_bytes()); + let hash = hasher.finalize(); + format!("{:x}", hash) +} \ No newline at end of file diff --git a/hydro_optimize_examples/src/lock_server.rs b/hydro_optimize_examples/src/lock_server.rs new file mode 100644 index 0000000..90afb66 --- /dev/null +++ b/hydro_optimize_examples/src/lock_server.rs @@ -0,0 +1,80 @@ +use hydro_lang::{ + live_collections::stream::NoOrder, + location::{Location, MemberId}, + nondet::nondet, + prelude::{Process, Stream, Unbounded}, +}; +use stageleft::q; + +pub struct Server {} + +/// Lock server implementation as described in https://dl.acm.org/doi/pdf/10.1145/3341301.3359651, with the difference being that each server can hold multiple locks. +/// Clients send (virt_client_id, server_id, acquire) requesting a lock from the server. +/// +/// If acquire = true, then: +/// - If the server currently holds the lock, it returns (virt_client_id, server_id, true). +/// - Otherwise, it returns (virt_client_id, server_id, false). +/// +/// If acquire = false, then the client wants to release its lock. Return (virt_client_id, server_id, true). +#[expect(clippy::type_complexity, reason = "internal Lock Server code // TODO")] +pub fn lock_server<'a, Client>( + server: &Process<'a, Server>, + payloads: Stream<(MemberId, (u32, u32, bool)), Process<'a, Server>, Unbounded, NoOrder>, +) -> Stream<(MemberId, (u32, u32, bool)), Process<'a, Server>, Unbounded, NoOrder> { + let server_tick = server.tick(); + let keyed_payloads = payloads.map(q!(|(client_id, (virt_client_id, server_id, acquire))| ( + server_id, + (client_id, virt_client_id, acquire) + ))); + + let batched_payloads = keyed_payloads + .batch( + &server_tick, + nondet!(/** Need to check who currently owns the lock */), + ) + .assume_ordering(nondet!(/** First to acquire the lock wins */)); + let lock_state = batched_payloads + .clone() + .persist() + .into_keyed() + .reduce(q!( + |(curr_client_id, curr_virt_client_id, is_held_by_client), + (client_id, virt_client_id, acquire)| { + if acquire { + // If the lock is currently held by the server, give the client the lock + if !*is_held_by_client { + *curr_client_id = client_id; + *curr_virt_client_id = virt_client_id; + *is_held_by_client = true; + } + } else { + // If the client is releasing the lock and it holds it, give the lock back to the server + if *is_held_by_client + && *curr_virt_client_id == virt_client_id + && *curr_client_id == client_id + { + *is_held_by_client = false; + } + } + } + )) + .entries(); + let results = batched_payloads.join(lock_state).all_ticks().map(q!(|( + server_id, + ( + (client_id, virt_client_id, acquire), + (curr_client_id, curr_virt_client_id, is_held_by_client), + ), + )| { + if acquire { + let acquired = is_held_by_client + && curr_client_id == client_id + && curr_virt_client_id == virt_client_id; + (client_id, (virt_client_id, server_id, acquired)) + } else { + // Releasing always succeeds + (client_id, (virt_client_id, server_id, true)) + } + })); + results +} diff --git a/hydro_optimize_examples/src/simple_graphs.rs b/hydro_optimize_examples/src/simple_graphs.rs new file mode 100644 index 0000000..b550336 --- /dev/null +++ b/hydro_optimize_examples/src/simple_graphs.rs @@ -0,0 +1,1021 @@ +use hydro_lang::{ + live_collections::stream::NoOrder, + location::{Location, MemberId}, + nondet::nondet, + prelude::{Cluster, KeyedStream, Unbounded}, +}; +use sha2::{Digest, Sha256}; +use stageleft::q; + +pub struct Client {} +pub struct Server {} + +pub trait GraphFunction<'a>: + Fn( + &Cluster<'a, Server>, + KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> +{ +} + +impl<'a, F> GraphFunction<'a> for F where + F: Fn( + &Cluster<'a, Server>, + KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, + ) + -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> +{ +} + +fn sha256(n: u32) -> u32 { + let mut sha_input = n; + + for _ in 0..n { + let mut sha = Sha256::new(); + sha.update(sha_input.to_be_bytes()); + let sha_output = sha.finalize(); + sha_input = sha_output[0].into(); + } + + sha_input +} + +// Note: H = high load, L = low load + +pub fn get_graph_function<'a>(name: &str) -> impl GraphFunction<'a> { + match name { + "map_h_map_h_map_h" => map_h_map_h_map_h, + "map_h_map_h_map_l" => map_h_map_h_map_l, + "map_h_map_l_map_h" => map_h_map_l_map_h, + "map_l_map_h_map_h" => map_l_map_h_map_h, + "map_h_map_l_map_l" => map_h_map_l_map_l, + "map_l_map_h_map_l" => map_l_map_h_map_l, + "map_l_map_l_map_h" => map_l_map_l_map_h, + "map_l_map_l_map_l" => map_l_map_l_map_l, + "map_l_first_map_l_second_union" => map_l_first_map_l_second_union, + "map_l_first_map_h_second_union" => map_l_first_map_h_second_union, + "map_h_first_map_l_second_union" => map_h_first_map_l_second_union, + "map_h_first_map_h_second_union" => map_h_first_map_h_second_union, + "map_l_map_l_first_payload_second_union" => map_l_map_l_first_payload_second_union, + "map_l_map_h_first_payload_second_union" => map_l_map_h_first_payload_second_union, + "map_h_map_l_first_payload_second_union" => map_h_map_l_first_payload_second_union, + "map_h_map_h_first_payload_second_union" => map_h_map_h_first_payload_second_union, + "map_l_first_payload_second_union_map_l" => map_l_first_payload_second_union_map_l, + "map_l_first_payload_second_union_map_h" => map_l_first_payload_second_union_map_h, + "map_h_first_payload_second_union_map_l" => map_h_first_payload_second_union_map_l, + "map_h_first_payload_second_union_map_h" => map_h_first_payload_second_union_map_h, + "map_l_first_map_l_second_anti_join" => map_l_first_map_l_second_anti_join, + "map_l_first_map_h_second_anti_join" => map_l_first_map_h_second_anti_join, + "map_h_first_map_l_second_anti_join" => map_h_first_map_l_second_anti_join, + "map_h_first_map_h_second_anti_join" => map_h_first_map_h_second_anti_join, + "map_l_map_l_first_payload_second_anti_join" => map_l_map_l_first_payload_second_anti_join, + "map_l_map_h_first_payload_second_anti_join" => map_l_map_h_first_payload_second_anti_join, + "map_h_map_l_first_payload_second_anti_join" => map_h_map_l_first_payload_second_anti_join, + "map_h_map_h_first_payload_second_anti_join" => map_h_map_h_first_payload_second_anti_join, + "map_l_first_payload_second_anti_join_map_l" => map_l_first_payload_second_anti_join_map_l, + "map_l_first_payload_second_anti_join_map_h" => map_l_first_payload_second_anti_join_map_h, + "map_h_first_payload_second_anti_join_map_l" => map_h_first_payload_second_anti_join_map_l, + "map_h_first_payload_second_anti_join_map_h" => map_h_first_payload_second_anti_join_map_h, + _ => unimplemented!(), + } +} + +pub fn map_h_map_h_map_h<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + payloads + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(100 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(100 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(100 + n % 2) + ))) +} + +pub fn map_h_map_h_map_l<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + payloads + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(100 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(100 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(n % 2 + 1) + ))) +} + +pub fn map_h_map_l_map_h<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + payloads + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(100 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(n % 2 + 1) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(100 + n % 2) + ))) +} + +pub fn map_l_map_h_map_h<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + payloads + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(n % 2 + 1) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(100 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(100 + n % 2) + ))) +} + +pub fn map_h_map_l_map_l<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + payloads + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(100 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(n % 2 + 1) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(n % 2 + 1) + ))) +} + +pub fn map_l_map_h_map_l<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + payloads + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(n % 2 + 1) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(100 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(n % 2 + 1) + ))) +} + +pub fn map_l_map_l_map_h<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + payloads + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(n % 2 + 1) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(n % 2 + 1) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(100 + n % 2) + ))) +} + +pub fn map_l_map_l_map_l<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + payloads + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(n % 2 + 1) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(n % 2 + 1) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(n % 2 + 1) + ))) +} + +pub fn map_l_first_map_l_second_union<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + let map_l1 = payloads + .clone() + .map(q!(|(_virt_client_id, n)| (None, self::sha256(n % 2 + 1)))); + let map_l2 = payloads.map(q!(|(virt_client_id, n)| ( + Some(virt_client_id), + self::sha256(n % 2 + 1) + ))); + map_l1 + .interleave(map_l2) + .filter_map(q!(|(virt_client_id_opt, n)| { + // Since we cloned payloads, delete half the payloads so 1 input = 1 output + if let Some(virt_client_id) = virt_client_id_opt { + Some((virt_client_id, n)) + } else { + None + } + })) +} + +pub fn map_l_first_map_h_second_union<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + let map_l1 = payloads + .clone() + .map(q!(|(_virt_client_id, n)| (None, self::sha256(n % 2 + 1)))); + let map_h2 = payloads.map(q!(|(virt_client_id, n)| ( + Some(virt_client_id), + self::sha256(100 + n % 2) + ))); + map_l1 + .interleave(map_h2) + .filter_map(q!(|(virt_client_id_opt, n)| { + // Since we cloned payloads, delete half the payloads so 1 input = 1 output + if let Some(virt_client_id) = virt_client_id_opt { + Some((virt_client_id, n)) + } else { + None + } + })) +} + +pub fn map_h_first_map_l_second_union<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + let map_h1 = payloads + .clone() + .map(q!(|(_virt_client_id, n)| (None, self::sha256(100 + n % 2)))); + let map_l2 = payloads.map(q!(|(virt_client_id, n)| ( + Some(virt_client_id), + self::sha256(n % 2 + 1) + ))); + map_h1 + .interleave(map_l2) + .filter_map(q!(|(virt_client_id_opt, n)| { + // Since we cloned payloads, delete half the payloads so 1 input = 1 output + if let Some(virt_client_id) = virt_client_id_opt { + Some((virt_client_id, n)) + } else { + None + } + })) +} + +pub fn map_h_first_map_h_second_union<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + let map_h1 = payloads + .clone() + .map(q!(|(_virt_client_id, n)| (None, self::sha256(100 + n % 2)))); + let map_h2 = payloads.map(q!(|(virt_client_id, n)| ( + Some(virt_client_id), + self::sha256(100 + n % 2) + ))); + map_h1 + .interleave(map_h2) + .filter_map(q!(|(virt_client_id_opt, n)| { + // Since we cloned payloads, delete half the payloads so 1 input = 1 output + if let Some(virt_client_id) = virt_client_id_opt { + Some((virt_client_id, n)) + } else { + None + } + })) +} + +pub fn map_l_map_l_first_payload_second_union<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + payloads + .clone() + .map(q!(|(_virt_client_id, n)| ( + None::, + self::sha256(n % 2 + 1) + ))) + .map(q!(|(_virt_client_id, n)| (None, self::sha256(n % 2 + 1)))) + .interleave(payloads.map(q!(|(virt_client_id, n)| (Some(virt_client_id), n)))) + .filter_map(q!(|(virt_client_id_opt, n)| { + // Since we cloned payloads, delete half the payloads so 1 input = 1 output + if let Some(virt_client_id) = virt_client_id_opt { + Some((virt_client_id, n)) + } else { + None + } + })) +} + +pub fn map_l_map_h_first_payload_second_union<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + payloads + .clone() + .map(q!(|(_virt_client_id, n)| ( + None::, + self::sha256(n % 2 + 1) + ))) + .map(q!(|(_virt_client_id, n)| (None, self::sha256(100 + n % 2)))) + .interleave(payloads.map(q!(|(virt_client_id, n)| (Some(virt_client_id), n)))) + .filter_map(q!(|(virt_client_id_opt, n)| { + // Since we cloned payloads, delete half the payloads so 1 input = 1 output + if let Some(virt_client_id) = virt_client_id_opt { + Some((virt_client_id, n)) + } else { + None + } + })) +} + +pub fn map_h_map_l_first_payload_second_union<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + payloads + .clone() + .map(q!(|(_virt_client_id, n)| ( + None::, + self::sha256(100 + n % 2) + ))) + .map(q!(|(_virt_client_id, n)| (None, self::sha256(n % 2 + 1)))) + .interleave(payloads.map(q!(|(virt_client_id, n)| (Some(virt_client_id), n)))) + .filter_map(q!(|(virt_client_id_opt, n)| { + // Since we cloned payloads, delete half the payloads so 1 input = 1 output + if let Some(virt_client_id) = virt_client_id_opt { + Some((virt_client_id, n)) + } else { + None + } + })) +} + +pub fn map_h_map_h_first_payload_second_union<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + payloads + .clone() + .map(q!(|(_virt_client_id, n)| ( + None::, + self::sha256(100 + n % 2) + ))) + .map(q!(|(_virt_client_id, n)| (None, self::sha256(100 + n % 2)))) + .interleave(payloads.map(q!(|(virt_client_id, n)| (Some(virt_client_id), n)))) + .filter_map(q!(|(virt_client_id_opt, n)| { + // Since we cloned payloads, delete half the payloads so 1 input = 1 output + if let Some(virt_client_id) = virt_client_id_opt { + Some((virt_client_id, n)) + } else { + None + } + })) +} + +pub fn map_l_first_payload_second_union_map_l<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + payloads + .clone() + .map(q!(|(_virt_client_id, n)| ( + None::, + self::sha256(n % 2 + 1) + ))) + .interleave(payloads.map(q!(|(virt_client_id, n)| (Some(virt_client_id), n)))) + .filter_map(q!(|(virt_client_id_opt, n)| { + let sha = self::sha256(n % 2 + 1); + // Since we cloned payloads, delete half the payloads so 1 input = 1 output + if let Some(virt_client_id) = virt_client_id_opt { + Some((virt_client_id, sha)) + } else { + None + } + })) +} + +pub fn map_l_first_payload_second_union_map_h<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + payloads + .clone() + .map(q!(|(_virt_client_id, n)| ( + None::, + self::sha256(n % 2 + 1) + ))) + .interleave(payloads.map(q!(|(virt_client_id, n)| (Some(virt_client_id), n)))) + .filter_map(q!(|(virt_client_id_opt, n)| { + let sha = self::sha256(100 + n % 2); + // Since we cloned payloads, delete half the payloads so 1 input = 1 output + if let Some(virt_client_id) = virt_client_id_opt { + Some((virt_client_id, sha)) + } else { + None + } + })) +} + +pub fn map_h_first_payload_second_union_map_l<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + payloads + .clone() + .map(q!(|(_virt_client_id, n)| ( + None::, + self::sha256(100 + n % 2) + ))) + .interleave(payloads.map(q!(|(virt_client_id, n)| (Some(virt_client_id), n)))) + .filter_map(q!(|(virt_client_id_opt, n)| { + let sha = self::sha256(n % 2 + 1); + // Since we cloned payloads, delete half the payloads so 1 input = 1 output + if let Some(virt_client_id) = virt_client_id_opt { + Some((virt_client_id, sha)) + } else { + None + } + })) +} + +pub fn map_h_first_payload_second_union_map_h<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + payloads + .clone() + .map(q!(|(_virt_client_id, n)| ( + None::, + self::sha256(100 + n % 2) + ))) + .interleave(payloads.map(q!(|(virt_client_id, n)| (Some(virt_client_id), n)))) + .filter_map(q!(|(virt_client_id_opt, n)| { + let sha = self::sha256(100 + n % 2); + // Since we cloned payloads, delete half the payloads so 1 input = 1 output + if let Some(virt_client_id) = virt_client_id_opt { + Some((virt_client_id, sha)) + } else { + None + } + })) +} + +pub fn map_l_first_map_l_second_anti_join<'a>( + server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + let tick = server.tick(); + let nondet = nondet!(/** Test */); + + let true_payloads = payloads + .clone() + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + true, + n + ))); + let map_l1 = payloads + .clone() + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + false, + self::sha256(n % 2 + 1) + ))) + .interleave(true_payloads) // The actual payloads that will pass the anti_join + .batch(&tick, nondet); + let map_l2 = payloads + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + false, + self::sha256(n % 2 + 1) + ))) + .batch(&tick, nondet); + map_l1 + .filter_not_in(map_l2) + .all_ticks() + .filter_map(q!(|(client_id, virt_client_id, keep, n)| { + if keep { + Some((client_id, (virt_client_id, n))) + } else { + None + } + })) + .into_keyed() +} + +pub fn map_l_first_map_h_second_anti_join<'a>( + server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + let tick = server.tick(); + let nondet = nondet!(/** Test */); + + let true_payloads = payloads + .clone() + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + true, + n + ))); + let map_l1 = payloads + .clone() + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + false, + self::sha256(n % 2 + 1) + ))) + .interleave(true_payloads) // The actual payloads that will pass the anti_join + .batch(&tick, nondet); + let map_h2 = payloads + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + false, + self::sha256(100 + n % 2) + ))) + .batch(&tick, nondet); + map_l1 + .filter_not_in(map_h2) + .all_ticks() + .filter_map(q!(|(client_id, virt_client_id, keep, n)| { + if keep { + Some((client_id, (virt_client_id, n))) + } else { + None + } + })) + .into_keyed() +} + +pub fn map_h_first_map_l_second_anti_join<'a>( + server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + let tick = server.tick(); + let nondet = nondet!(/** Test */); + + let true_payloads = payloads + .clone() + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + true, + n + ))); + let map_h1 = payloads + .clone() + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + false, + self::sha256(100 + n % 2) + ))) + .interleave(true_payloads) // The actual payloads that will pass the anti_join + .batch(&tick, nondet); + let map_l2 = payloads + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + false, + self::sha256(n % 2 + 1) + ))) + .batch(&tick, nondet); + map_h1 + .filter_not_in(map_l2) + .all_ticks() + .filter_map(q!(|(client_id, virt_client_id, keep, n)| { + if keep { + Some((client_id, (virt_client_id, n))) + } else { + None + } + })) + .into_keyed() +} + +pub fn map_h_first_map_h_second_anti_join<'a>( + server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + let tick = server.tick(); + let nondet = nondet!(/** Test */); + + let true_payloads = payloads + .clone() + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + true, + n + ))); + let map_h1 = payloads + .clone() + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + false, + self::sha256(100 + n % 2) + ))) + .interleave(true_payloads) // The actual payloads that will pass the anti_join + .batch(&tick, nondet); + let map_h2 = payloads + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + false, + self::sha256(100 + n % 2) + ))) + .batch(&tick, nondet); + map_h1 + .filter_not_in(map_h2) + .all_ticks() + .filter_map(q!(|(client_id, virt_client_id, keep, n)| { + if keep { + Some((client_id, (virt_client_id, n))) + } else { + None + } + })) + .into_keyed() +} + +pub fn map_l_map_l_first_payload_second_anti_join<'a>( + server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + let tick = server.tick(); + let nondet = nondet!(/** Test */); + + let false_payloads = payloads + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + n, + false + ))); + false_payloads + .clone() + .map(q!(|(client_id, virt_client_id, n, _keep)| ( + client_id, + virt_client_id, + self::sha256(n % 2 + 1), + true + ))) + .map(q!(|(client_id, virt_client_id, n, _keep)| ( + client_id, + virt_client_id, + self::sha256(n % 2 + 1), + true + ))) + .interleave(false_payloads.clone()) + .batch(&tick, nondet) + .filter_not_in(false_payloads.batch(&tick, nondet)) + .all_ticks() + .filter_map(q!(|(client_id, virt_client_id, n, keep)| { + if keep { + Some((client_id, (virt_client_id, n))) + } else { + None + } + })) + .into_keyed() +} + +pub fn map_l_map_h_first_payload_second_anti_join<'a>( + server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + let tick = server.tick(); + let nondet = nondet!(/** Test */); + + let false_payloads = payloads + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + n, + false + ))); + false_payloads + .clone() + .map(q!(|(client_id, virt_client_id, n, _keep)| ( + client_id, + virt_client_id, + self::sha256(n % 2 + 1), + true + ))) + .map(q!(|(client_id, virt_client_id, n, _keep)| ( + client_id, + virt_client_id, + self::sha256(100 + n % 2), + true + ))) + .interleave(false_payloads.clone()) + .batch(&tick, nondet) + .filter_not_in(false_payloads.batch(&tick, nondet)) + .all_ticks() + .filter_map(q!(|(client_id, virt_client_id, n, keep)| { + if keep { + Some((client_id, (virt_client_id, n))) + } else { + None + } + })) + .into_keyed() +} + +pub fn map_h_map_l_first_payload_second_anti_join<'a>( + server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + let tick = server.tick(); + let nondet = nondet!(/** Test */); + + let false_payloads = payloads + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + n, + false + ))); + false_payloads + .clone() + .map(q!(|(client_id, virt_client_id, n, _keep)| ( + client_id, + virt_client_id, + self::sha256(100 + n % 2), + true + ))) + .map(q!(|(client_id, virt_client_id, n, _keep)| ( + client_id, + virt_client_id, + self::sha256(n % 2 + 1), + true + ))) + .interleave(false_payloads.clone()) + .batch(&tick, nondet) + .filter_not_in(false_payloads.batch(&tick, nondet)) + .all_ticks() + .filter_map(q!(|(client_id, virt_client_id, n, keep)| { + if keep { + Some((client_id, (virt_client_id, n))) + } else { + None + } + })) + .into_keyed() +} + +pub fn map_h_map_h_first_payload_second_anti_join<'a>( + server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + let tick = server.tick(); + let nondet = nondet!(/** Test */); + + let false_payloads = payloads + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + n, + false + ))); + false_payloads + .clone() + .map(q!(|(client_id, virt_client_id, n, _keep)| ( + client_id, + virt_client_id, + self::sha256(100 + n % 2), + true + ))) + .map(q!(|(client_id, virt_client_id, n, _keep)| ( + client_id, + virt_client_id, + self::sha256(100 + n % 2), + true + ))) + .interleave(false_payloads.clone()) + .batch(&tick, nondet) + .filter_not_in(false_payloads.batch(&tick, nondet)) + .all_ticks() + .filter_map(q!(|(client_id, virt_client_id, n, keep)| { + if keep { + Some((client_id, (virt_client_id, n))) + } else { + None + } + })) + .into_keyed() +} + +pub fn map_l_first_payload_second_anti_join_map_l<'a>( + server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + let tick = server.tick(); + let nondet = nondet!(/** Test */); + + let false_payloads = payloads + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + n, + false + ))); + + false_payloads + .clone() + .map(q!(|(client, virt_client_id, n, _keep)| ( + client, + virt_client_id, + self::sha256(n % 2 + 1), + true + ))) + .interleave(false_payloads.clone()) + .batch(&tick, nondet) + .filter_not_in(false_payloads.clone().batch(&tick, nondet)) + .all_ticks() + .filter_map(q!(|(client, virt_client_id, n, keep)| { + if keep { + Some((client, (virt_client_id, self::sha256(n % 2 + 1)))) + } else { + None + } + })) + .into_keyed() +} + +pub fn map_l_first_payload_second_anti_join_map_h<'a>( + server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + let tick = server.tick(); + let nondet = nondet!(/** Test */); + + let false_payloads = payloads + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + n, + false + ))); + + false_payloads + .clone() + .map(q!(|(client, virt_client_id, n, _keep)| ( + client, + virt_client_id, + self::sha256(n % 2 + 1), + true + ))) + .interleave(false_payloads.clone()) + .batch(&tick, nondet) + .filter_not_in(false_payloads.clone().batch(&tick, nondet)) + .all_ticks() + .filter_map(q!(|(client, virt_client_id, n, keep)| { + if keep { + Some((client, (virt_client_id, self::sha256(100 + n % 2)))) + } else { + None + } + })) + .into_keyed() +} + +pub fn map_h_first_payload_second_anti_join_map_l<'a>( + server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + let tick = server.tick(); + let nondet = nondet!(/** Test */); + + let false_payloads = payloads + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + n, + false + ))); + + false_payloads + .clone() + .map(q!(|(client, virt_client_id, n, _keep)| ( + client, + virt_client_id, + self::sha256(100 + n % 2), + true + ))) + .interleave(false_payloads.clone()) + .batch(&tick, nondet) + .filter_not_in(false_payloads.clone().batch(&tick, nondet)) + .all_ticks() + .filter_map(q!(|(client, virt_client_id, n, keep)| { + if keep { + Some((client, (virt_client_id, self::sha256(n % 2 + 1)))) + } else { + None + } + })) + .into_keyed() +} + +pub fn map_h_first_payload_second_anti_join_map_h<'a>( + server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + let tick = server.tick(); + let nondet = nondet!(/** Test */); + + let false_payloads = payloads + .entries() + .map(q!(|(client_id, (virt_client_id, n))| ( + client_id, + virt_client_id, + n, + false + ))); + + false_payloads + .clone() + .map(q!(|(client, virt_client_id, n, _keep)| ( + client, + virt_client_id, + self::sha256(100 + n % 2), + true + ))) + .interleave(false_payloads.clone()) + .batch(&tick, nondet) + .filter_not_in(false_payloads.clone().batch(&tick, nondet)) + .all_ticks() + .filter_map(q!(|(client, virt_client_id, n, keep)| { + if keep { + Some((client, (virt_client_id, self::sha256(100 + n % 2)))) + } else { + None + } + })) + .into_keyed() +} diff --git a/hydro_optimize_examples/src/simple_graphs_bench.rs b/hydro_optimize_examples/src/simple_graphs_bench.rs new file mode 100644 index 0000000..84bb2e8 --- /dev/null +++ b/hydro_optimize_examples/src/simple_graphs_bench.rs @@ -0,0 +1,33 @@ +use hydro_lang::{prelude::{Cluster, Process}, nondet::nondet}; +use hydro_std::bench_client::{bench_client, print_bench_results}; + +use hydro_test::cluster::paxos_bench::inc_u32_workload_generator; +use crate::simple_graphs::{Client, GraphFunction, Server}; +pub struct Aggregator; + +pub fn simple_graphs_bench<'a>( + num_clients_per_node: usize, + server: &Cluster<'a, Server>, + clients: &Cluster<'a, Client>, + client_aggregator: &Process<'a, Aggregator>, + graph: impl GraphFunction<'a>, +) { + let bench_results = bench_client( + clients, + inc_u32_workload_generator, + |payloads| { + graph( + server, + payloads + .broadcast_bincode(server, nondet!(/** Test */)) + .into(), + ) + .demux_bincode(clients) + .values() + }, + num_clients_per_node, + nondet!(/** bench */), + ); + + print_bench_results(bench_results, client_aggregator, clients); +} \ No newline at end of file diff --git a/hydro_optimize_examples/src/simple_kv_bench.rs b/hydro_optimize_examples/src/simple_kv_bench.rs new file mode 100644 index 0000000..89aaa1b --- /dev/null +++ b/hydro_optimize_examples/src/simple_kv_bench.rs @@ -0,0 +1,140 @@ +use hydro_lang::{ + location::Location, + nondet::nondet, + prelude::{Cluster, Process}, +}; +use hydro_std::bench_client::{bench_client, print_bench_results}; + +use hydro_test::cluster::paxos_bench::inc_u32_workload_generator; +use stageleft::q; + +pub struct Kv; +pub struct Client; +pub struct Aggregator; + +pub fn simple_kv_bench<'a>( + num_clients_per_node: usize, + kv: &Process<'a, Kv>, + clients: &Cluster<'a, Client>, + client_aggregator: &Process<'a, Aggregator>, +) { + let bench_results = bench_client( + clients, + inc_u32_workload_generator, + |payloads| { + let k_tick = kv.tick(); + let k_payloads = payloads.send_bincode(kv).batch(&k_tick, nondet!(/** TODO: Actually can use atomic() here, but there's no way to exit atomic in KeyedStreams? */)); + + // Insert each payload into the KV store + k_payloads + .clone() + .values() + .assume_ordering(nondet!(/** Last writer wins. TODO: Technically, we only need to assume ordering over the keyed stream (ordering of values with different keys doesn't matter. But there's no .persist() for KeyedStreams) */)) + .persist() + .into_keyed() + .reduce(q!(|prev, new| { + *prev = new; + })) + .entries() + .all_ticks() + .for_each(q!(|_| {})); // Do nothing, just need to end on a HydroLeaf + + // Send committed requests back to the original client + k_payloads.all_ticks().demux_bincode(clients).into() + }, + num_clients_per_node, + nondet!(/** bench */), + ); + + print_bench_results(bench_results, client_aggregator, clients); +} + +#[cfg(test)] +mod tests { + use dfir_lang::graph::WriteConfig; + use hydro_build_utils::insta; + use hydro_deploy::Deployment; + use hydro_lang::{ + compile::ir::dbg_dedup_tee, + deploy::{DeployCrateWrapper, HydroDeploy, TrybuildHost}, + prelude::FlowBuilder, + }; + use std::str::FromStr; + + use regex::Regex; + + #[cfg(stageleft_runtime)] + use crate::simple_kv_bench::simple_kv_bench; + + #[test] + fn simple_kv_ir() { + let builder = FlowBuilder::new(); + let kv = builder.process(); + let clients = builder.cluster(); + let client_aggregator = builder.process(); + + simple_kv_bench(1, &kv, &clients, &client_aggregator); + let built = builder.with_default_optimize::(); + + dbg_dedup_tee(|| { + insta::assert_debug_snapshot!(built.ir()); + }); + + let preview = built.preview_compile(); + insta::with_settings!({snapshot_suffix => "kv_mermaid"}, { + insta::assert_snapshot!( + preview.dfir_for(&kv).to_mermaid(&WriteConfig { + no_subgraphs: true, + no_pull_push: true, + no_handoffs: true, + op_text_no_imports: true, + ..WriteConfig::default() + }) + ); + }); + } + + #[tokio::test] + async fn simple_kv_some_throughput() { + let builder = FlowBuilder::new(); + let kv = builder.process(); + let clients = builder.cluster(); + let client_aggregator = builder.process(); + + simple_kv_bench(1, &kv, &clients, &client_aggregator); + let mut deployment = Deployment::new(); + + let nodes = builder + .with_process(&kv, TrybuildHost::new(deployment.Localhost())) + .with_cluster(&clients, vec![TrybuildHost::new(deployment.Localhost())]) + .with_process( + &client_aggregator, + TrybuildHost::new(deployment.Localhost()), + ) + .deploy(&mut deployment); + + deployment.deploy().await.unwrap(); + + let client_node = &nodes.get_process(&client_aggregator); + let client_out = client_node.stdout_filter("Throughput:").await; + + deployment.start().await.unwrap(); + + let re = Regex::new(r"Throughput: ([^ ]+) - ([^ ]+) - ([^ ]+) requests/s").unwrap(); + let mut found = 0; + let mut client_out = client_out; + while let Some(line) = client_out.recv().await { + if let Some(caps) = re.captures(&line) { + if let Ok(lower) = f64::from_str(&caps[1]) { + if lower > 0.0 { + println!("Found throughput lower-bound: {}", lower); + found += 1; + if found == 2 { + break; + } + } + } + } + } + } +} diff --git a/hydro_optimize_examples/src/web_submit.rs b/hydro_optimize_examples/src/web_submit.rs new file mode 100644 index 0000000..61d216b --- /dev/null +++ b/hydro_optimize_examples/src/web_submit.rs @@ -0,0 +1,404 @@ +use std::collections::{HashMap, HashSet}; + +use hydro_lang::{ + live_collections::stream::NoOrder, + location::{Location, MemberId}, + nondet::nondet, + prelude::{Process, Stream, Unbounded}, +}; +use sha2::{Digest, Sha256}; +use stageleft::q; + +pub struct Server {} + +/// Implementation of WebSubmit https://github.com/ms705/websubmit-rs/tree/master. +/// We expose the following APIs: +/// - add_lecture (takes api_key, lecture_id, lecture, only approves if user is admin) +/// - add_question (takes api_key, question, question_id, lecture_id, only approves if user is admin) +/// - add_user (takes user_email, is_admin, hashes user's email + secret, stores API key in table, emails them the key, should only approve if user is admin but it's tautological so just approve everyone) +/// - get_users (takes api_key, only approves if caller is admin, returns user_id, user_email, user_is_admin) +/// - list_lectures (takes api_key, returns lecture_id, lecture) +/// - list_lecture_questions_all (takes api_key & lecture_id, returns question, question_id, optional answer joining on answer_id = question_id, only approves if user is admin) +/// - list_lecture_questions_user (takes api_key & lecture_id, returns question, question_id, optional answer joining on answer_id = question_id if this user wrote the answer) +/// - add_answer (takes api_key, question_id, answer) +/// +/// Any call with an invalid API key (either it does not exist or does not have the privileges required) will not receive a response. +#[expect( + clippy::too_many_arguments, + clippy::type_complexity, + reason = "internal Web Submit code // TODO" +)] +pub fn web_submit<'a, Client>( + server: &Process<'a, Server>, + add_lecture: Stream< + (MemberId, (String, u32, String)), + Process<'a, Server>, + Unbounded, + NoOrder, + >, + add_question: Stream< + (MemberId, (String, String, u32, u32)), + Process<'a, Server>, + Unbounded, + NoOrder, + >, + add_user: Stream<(MemberId, (String, bool)), Process<'a, Server>, Unbounded, NoOrder>, + get_users: Stream<(MemberId, String), Process<'a, Server>, Unbounded, NoOrder>, + list_lectures: Stream<(MemberId, String), Process<'a, Server>, Unbounded, NoOrder>, + list_lecture_questions_all: Stream< + (MemberId, (String, u32)), + Process<'a, Server>, + Unbounded, + NoOrder, + >, + list_lecture_questions_user: Stream< + (MemberId, (String, u32)), + Process<'a, Server>, + Unbounded, + NoOrder, + >, + add_answer: Stream< + (MemberId, (String, u32, String)), + Process<'a, Server>, + Unbounded, + NoOrder, + >, +) -> ( + Stream<(MemberId, ()), Process<'a, Server>, Unbounded, NoOrder>, + Stream<(MemberId, ()), Process<'a, Server>, Unbounded, NoOrder>, + Stream<(MemberId, ()), Process<'a, Server>, Unbounded, NoOrder>, + Stream<(MemberId, HashMap), Process<'a, Server>, Unbounded, NoOrder>, + Stream<(MemberId, HashMap), Process<'a, Server>, Unbounded, NoOrder>, + Stream< + (MemberId, HashMap)>), + Process<'a, Server>, + Unbounded, + NoOrder, + >, + Stream< + (MemberId, HashMap)>), + Process<'a, Server>, + Unbounded, + NoOrder, + >, + Stream<(MemberId, ()), Process<'a, Server>, Unbounded, NoOrder>, +) { + let user_auth_tick = server.tick(); + let lectures_tick = server.tick(); + let question_answer_tick = server.tick(); + + // Add user + let add_user_with_api_key = add_user.map(q!(|(client_id, (email, is_admin))| { + let api_key = self::generate_api_key(email.clone()); + (client_id, (email, is_admin, api_key)) + })); + let users_this_tick_with_api_key = add_user_with_api_key.batch( + &user_auth_tick, + nondet!(/** Snapshot current users to approve/deny access */), + ); + // Persisted users + let curr_users = users_this_tick_with_api_key + .clone() + .map(q!(|(_client_id, (email, is_admin, api_key))| ( + api_key, + (email, is_admin) + ))) + .persist(); + let curr_users_hashmap = curr_users.clone().fold_commutative_idempotent( + q!(|| HashMap::new()), + q!(|map, (_api_key, (email, is_admin))| { + map.insert(email, is_admin); + }), + ); + // Email the API key. Only done after the tick to ensure that once the client gets the email, the user has been added + users_this_tick_with_api_key + .clone() + .all_ticks() + .for_each(q!(|(_client_id, (email, _is_admin, api_key))| { + self::send_email(api_key, email) + })); + // Send response back to client. Only done after the tick to ensure that once the client gets the response, the user has been added + let add_user_response = + users_this_tick_with_api_key.all_ticks().map(q!(|( + client_id, + (_email, _is_admin, _api_key), + )| (client_id, ()))); + + // Add lecture + let add_lecture_pre_join = + add_lecture.map(q!(|(client_id, (api_key, lecture_id, lecture))| { + (api_key, (client_id, lecture_id, lecture)) + })); + let lectures = add_lecture_pre_join + .batch( + &user_auth_tick, + nondet!(/** Compare against current users to approve/deny access */), + ) + .join(curr_users.clone()) + .all_ticks() + .filter(q!(|( + _api_key, + ((_client_id, _lecture_id, _lecture), (_email, is_admin)), + )| *is_admin)); + let curr_lectures = + lectures.batch(&lectures_tick, nondet!(/** Snapshot of current lectures */)); + let curr_lectures_hashmap = curr_lectures.clone().persist().fold_commutative_idempotent( + q!(|| HashMap::new()), + q!( + |map, (_api_key, ((_client_id, lecture_id, lecture), (_email, _is_admin)))| { + map.insert(lecture_id, lecture); + } + ), + ); + // Only done after the lectures_tick to ensure that once the client gets the response, the lecture has been added + let add_lecture_response = curr_lectures.all_ticks().map(q!(|( + _api_key, + ((client_id, _lecture_id, _lecture), (_email, _is_admin)), + )| (client_id, ()))); + + // Add question + let add_question_pre_join = add_question.map(q!(|( + client_id, + (api_key, question, question_id, lecture_id), + )| { + (api_key, (client_id, question, question_id, lecture_id)) + })); + let add_question_auth = add_question_pre_join + .batch( + &user_auth_tick, + nondet!(/** Compare against current users to approve/deny access */), + ) + .join(curr_users.clone()) + .all_ticks() + .filter(q!(|( + _api_key, + ((_client_id, _question, _question_id, _lecture_id), (_email, is_admin)), + )| *is_admin)); + let add_question_this_tick = add_question_auth.batch( + &question_answer_tick, + nondet!(/** Snapshot of current questions */), + ); + let curr_questions = add_question_this_tick + .clone() + .map(q!(|( + _api_key, + ((_client_id, question, question_id, lecture_id), (_email, _is_admin)), + )| (lecture_id, (question_id, question)))) + .persist(); + // Only done after the question_answer_tick to ensure that once the client gets the response, the question has been added + let add_question_response = add_question_this_tick.all_ticks().map(q!(|( + _api_key, + ((client_id, _question, _question_id, _lecture_id), (_email, _is_admin)), + )| (client_id, ()))); + + // Get users + let get_users_pre_join = get_users.map(q!(|(client_id, api_key)| (api_key, client_id))); + let get_users_response = get_users_pre_join + .batch( + &user_auth_tick, + nondet!(/** Compare against current users to approve/deny access */), + ) + .join(curr_users.clone()) + .filter_map(q!(|(_api_key, (client_id, (_email, is_admin)))| { + if is_admin { Some(client_id) } else { None } + })) + .cross_singleton(curr_users_hashmap) + .all_ticks(); + + // List lectures + let list_lectures_pre_join = list_lectures.map(q!(|(client_id, api_key)| (api_key, client_id))); + let list_lectures_auth = list_lectures_pre_join + .batch( + &user_auth_tick, + nondet!(/** Compare against current users to approve/deny access */), + ) + .join(curr_users.clone()) + .all_ticks() + .map(q!(|(_api_key, (client_id, (_email, _is_admin)))| client_id)); + let list_lectures_response = list_lectures_auth + .batch( + &lectures_tick, + nondet!(/** Join with snapshot of current lectures */), + ) + .cross_singleton(curr_lectures_hashmap) + .all_ticks(); + + // Add answer + let add_answer_pre_join = add_answer.map(q!(|(client_id, (api_key, question_id, answer))| { + (api_key, (client_id, question_id, answer)) + })); + let add_answer_auth = add_answer_pre_join + .batch( + &user_auth_tick, + nondet!(/** Compare against current users to approve/deny access */), + ) + .join(curr_users.clone()) + .all_ticks(); + let add_answer_this_tick = add_answer_auth.batch( + &question_answer_tick, + nondet!(/** Snapshot of current answers */), + ); + let curr_answers = add_answer_this_tick + .clone() + .map(q!(|( + api_key, + ((_client_id, question_id, answer), (_email, _is_admin)), + )| ((question_id, api_key), answer))) + .persist(); + // Only done after the question_answer_tick to ensure that once the client gets the response, the answer has been added + let add_answer_response = add_answer_this_tick.all_ticks().map(q!(|( + _api_key, + ((client_id, _question_id, _answer), (_email, _is_admin)), + )| (client_id, ()))); + + // List lecture questions all + let list_lecture_questions_all_pre_join = + list_lecture_questions_all.map(q!(|(client_id, (api_key, lecture_id))| { + (api_key, (client_id, lecture_id)) + })); + let list_lecture_questions_all_auth = list_lecture_questions_all_pre_join + .batch( + &user_auth_tick, + nondet!(/** Compare against current users to approve/deny access */), + ) + .join(curr_users.clone()) + .all_ticks() + .filter_map(q!(|( + _api_key, + ((client_id, lecture_id), (_email, is_admin)), + )| { + if is_admin { + Some((lecture_id, client_id)) + } else { + None + } + })); + // Find all questions with that ID + let list_lecture_questions_all_question_only = list_lecture_questions_all_auth + .batch( + &question_answer_tick, + nondet!(/** Join with snapshot of current questions */), + ) + .join(curr_questions.clone()) + .map(q!(|(_lecture_id, (client_id, (question_id, question)))| ( + question_id, + (client_id, question) + ))); + // Don't need to join on api_key since we're getting all answers, regardless of who wrote them + let curr_answers_no_api_key = + curr_answers + .clone() + .map(q!(|((question_id, _api_key), answer)| ( + question_id, + answer + ))); + // Find all answers with the question ID + let list_lecture_questions_all_with_answer = list_lecture_questions_all_question_only + .clone() + .join(curr_answers_no_api_key.clone()) + .map(q!(|(question_id, ((client_id, question), answer))| { + (client_id, (question_id, question, Some(answer))) + })); + // Find all questions without answers + let list_lecture_questions_all_no_answer = list_lecture_questions_all_question_only + .anti_join(curr_answers_no_api_key.map(q!(|(question_id, _answer)| question_id))) + .map(q!(|(question_id, (client_id, question))| ( + client_id, + (question_id, question, None) + ))); + let list_lecture_questions_all_response = list_lecture_questions_all_with_answer + .chain(list_lecture_questions_all_no_answer) + .into_keyed() + .fold_commutative_idempotent( + q!(|| HashMap::new()), + q!(|map, (question_id, question, answer)| { + let (_question, set_of_answers) = + map.entry(question_id).or_insert((question, HashSet::new())); + if let Some(answer) = answer { + set_of_answers.insert(answer); + } + }), + ) + .entries() + .all_ticks(); + + // List lecture questions user + let list_lecture_questions_user_pre_join = + list_lecture_questions_user.map(q!(|(client_id, (api_key, lecture_id))| { + (api_key, (client_id, lecture_id)) + })); + let list_lecture_questions_user_auth = list_lecture_questions_user_pre_join + .batch( + &user_auth_tick, + nondet!(/** Compare against current users to approve/deny access */), + ) + .join(curr_users.clone()) + .all_ticks() + .map(q!(|( + api_key, + ((client_id, lecture_id), (_email, _is_admin)), + )| (lecture_id, (client_id, api_key)))); + let list_lecture_questions_user_question_only = list_lecture_questions_user_auth + .batch( + &question_answer_tick, + nondet!(/** Join with snapshot of current questions */), + ) + .join(curr_questions) + .map(q!(|( + _lecture_id, + ((client_id, api_key), (question_id, question)), + )| ( + (question_id, api_key), + (client_id, question) + ))); + // Find all answers with the question ID + let list_lecture_questions_user_with_answer = list_lecture_questions_user_question_only + .clone() + .join(curr_answers.clone()) + .map(q!(|( + (question_id, _api_key), + ((client_id, question), answer), + )| { + (client_id, (question_id, question, Some(answer))) + })); + // Find all questions without answers + let list_lecture_questions_user_no_answer = list_lecture_questions_user_question_only + .anti_join(curr_answers.map(q!(|(k, _)| k))) + .map(q!(|((question_id, _api_key), (client_id, question))| ( + client_id, + (question_id, question, None) + ))); + let list_lecture_questions_user_response = list_lecture_questions_user_with_answer + .chain(list_lecture_questions_user_no_answer) + .into_keyed() + .fold_commutative_idempotent( + q!(|| HashMap::new()), + q!(|map, (question_id, question, answer)| { + map.insert(question_id, (question, answer)); + }), + ) + .entries() + .all_ticks(); + + ( + add_lecture_response, + add_question_response, + add_user_response, + get_users_response, + list_lectures_response, + list_lecture_questions_all_response, + list_lecture_questions_user_response, + add_answer_response, + ) +} + +fn generate_api_key(email: String) -> String { + let secret = "There is no secret ingredient"; + let mut hasher = Sha256::new(); + hasher.update(email.as_bytes()); + hasher.update(secret.as_bytes()); + let hash = hasher.finalize(); + format!("{:x}", hash) +} + +fn send_email(_api_key: String, _email: String) {} From 505b332bfad2d9c6f995509ffc62dc45bffe8dab Mon Sep 17 00:00:00 2001 From: David Chu Date: Tue, 23 Sep 2025 00:04:14 +0000 Subject: [PATCH 03/35] Change dependencies to be local, merge with hydro main (add support for ChainFirst, remove delta, duplicate private functions), change simple_graphs to be time-based --- Cargo.lock | 10 +- Cargo.toml | 18 ++- hydro_optimize/Cargo.toml | 30 ++-- hydro_optimize/src/decoupler.rs | 17 +- hydro_optimize/src/deploy_and_analyze.rs | 1 + hydro_optimize/src/partition_node_analysis.rs | 153 +++++++++--------- hydro_optimize/src/partitioner.rs | 5 +- hydro_optimize/src/rewrites.rs | 56 +++++++ hydro_optimize_examples/Cargo.toml | 30 ++-- hydro_optimize_examples/src/simple_graphs.rs | 6 +- .../src/simple_kv_bench.rs | 2 + hydro_optimize_examples/src/web_submit.rs | 2 + 12 files changed, 206 insertions(+), 124 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 45112e3..972763a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1049,7 +1049,6 @@ dependencies = [ [[package]] name = "dfir_lang" version = "0.14.0" -source = "git+https://github.com/hydro-project/hydro.git#c01575c6f8d249cb0f96e0bc92761bae309e294b" dependencies = [ "auto_impl", "documented", @@ -1705,7 +1704,6 @@ checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" [[package]] name = "hydro_build_utils" version = "0.0.1" -source = "git+https://github.com/hydro-project/hydro.git#c01575c6f8d249cb0f96e0bc92761bae309e294b" dependencies = [ "insta", "rustc_version", @@ -1714,7 +1712,6 @@ dependencies = [ [[package]] name = "hydro_deploy" version = "0.14.0" -source = "git+https://github.com/hydro-project/hydro.git#c01575c6f8d249cb0f96e0bc92761bae309e294b" dependencies = [ "anyhow", "async-process", @@ -1750,7 +1747,6 @@ dependencies = [ [[package]] name = "hydro_deploy_integration" version = "0.14.0" -source = "git+https://github.com/hydro-project/hydro.git#c01575c6f8d249cb0f96e0bc92761bae309e294b" dependencies = [ "async-recursion", "async-trait", @@ -1767,7 +1763,6 @@ dependencies = [ [[package]] name = "hydro_lang" version = "0.14.0" -source = "git+https://github.com/hydro-project/hydro.git#c01575c6f8d249cb0f96e0bc92761bae309e294b" dependencies = [ "auto_impl", "backtrace", @@ -1816,7 +1811,9 @@ dependencies = [ "hydro_std", "hydro_test", "include_mdtests", + "proc-macro-crate", "proc-macro2", + "quote", "regex", "serde", "stageleft", @@ -1848,7 +1845,6 @@ dependencies = [ [[package]] name = "hydro_std" version = "0.14.0" -source = "git+https://github.com/hydro-project/hydro.git#c01575c6f8d249cb0f96e0bc92761bae309e294b" dependencies = [ "hdrhistogram", "hydro_lang", @@ -1860,7 +1856,6 @@ dependencies = [ [[package]] name = "hydro_test" version = "0.0.0" -source = "git+https://github.com/hydro-project/hydro.git#c01575c6f8d249cb0f96e0bc92761bae309e294b" dependencies = [ "bytes", "colored", @@ -2072,7 +2067,6 @@ dependencies = [ [[package]] name = "include_mdtests" version = "0.0.0" -source = "git+https://github.com/hydro-project/hydro.git#c01575c6f8d249cb0f96e0bc92761bae309e294b" dependencies = [ "glob", "proc-macro2", diff --git a/Cargo.toml b/Cargo.toml index 2553f9b..8b129b8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,4 +5,20 @@ members = [ "hydro_optimize_examples", ] -resolver = "2" \ No newline at end of file +resolver = "2" + +[workspace.dependencies] +hydro_lang = { path = "../hydroflow/hydro_lang" } +hydro_std = { path = "../hydroflow/hydro_std" } +hydro_test = { path = "../hydroflow/hydro_test" } +dfir_lang = { path = "../hydroflow/dfir_lang" } +hydro_build_utils = { path = "../hydroflow/hydro_build_utils" } +hydro_deploy = { path = "../hydroflow/hydro_deploy/core" } +include_mdtests = { path = "../hydroflow/include_mdtests" } +serde = { version = "1.0.197", features = ["derive"] } +stageleft = "0.9.7" +stageleft_tool = "0.9.7" +tokio = { version = "1.29.0", features = ["full"] } +ctor = "0.2" +clap = { version = "4.4", features = ["derive"] } +regex = "1.11.1" \ No newline at end of file diff --git a/hydro_optimize/Cargo.toml b/hydro_optimize/Cargo.toml index 2c664e4..ef16de4 100644 --- a/hydro_optimize/Cargo.toml +++ b/hydro_optimize/Cargo.toml @@ -11,27 +11,29 @@ all-features = true [dependencies] good_lp = { version = "1.14.0", features = ["microlp"], default-features = false } -hydro_deploy = { git = "https://github.com/hydro-project/hydro.git" } -hydro_lang = { git = "https://github.com/hydro-project/hydro.git", features = ["deploy"] } +hydro_deploy.workspace = true +hydro_lang = { workspace = true, features = ["deploy"] } proc-macro2 = "1.0.95" -regex = "1.11.1" -serde = { version = "1.0.197", features = ["derive"] } -stageleft = "0.9.7" +regex.workspace = true +serde.workspace = true +stageleft.workspace = true syn = { version = "2.0.46", features = [ "parsing", "extra-traits", "visit-mut", ] } -tokio = { version = "1.29.0", features = ["full"] } +tokio.workspace = true +proc-macro-crate = "3.3" +quote = "1.0.35" [dev-dependencies] -ctor = "0.2" -hydro_build_utils = { git = "https://github.com/hydro-project/hydro.git", version = "0.0.1" } -hydro_lang = { git = "https://github.com/hydro-project/hydro.git", version = "^0.14.0", features = ["viz"] } -hydro_test = { git = "https://github.com/hydro-project/hydro.git", version = "^0.0.0" } -hydro_std = { git = "https://github.com/hydro-project/hydro.git", version = "^0.14.0" } -clap = { version = "4.4", features = ["derive"] } -include_mdtests = { git = "https://github.com/hydro-project/hydro.git", version = "^0.0.0" } +ctor.workspace = true +hydro_build_utils.workspace = true +hydro_lang = { workspace = true, features = ["viz"] } +hydro_test.workspace = true +hydro_std.workspace = true +clap.workspace = true +include_mdtests.workspace = true [build-dependencies] -hydro_build_utils = { git = "https://github.com/hydro-project/hydro.git", version = "0.0.1" } \ No newline at end of file +hydro_build_utils.workspace = true \ No newline at end of file diff --git a/hydro_optimize/src/decoupler.rs b/hydro_optimize/src/decoupler.rs index 6a4d512..e7d6cd4 100644 --- a/hydro_optimize/src/decoupler.rs +++ b/hydro_optimize/src/decoupler.rs @@ -6,9 +6,6 @@ use hydro_lang::compile::ir::{ DebugInstantiate, DebugType, HydroIrMetadata, HydroIrOpMetadata, HydroNode, HydroRoot, TeeNode, transform_bottom_up, traverse_dfir, }; -use hydro_lang::live_collections::stream::networking::{ - deserialize_bincode_with_type, serialize_bincode_with_type, -}; use hydro_lang::location::MemberId; use hydro_lang::location::dynamic::LocationId; use proc_macro2::Span; @@ -18,7 +15,7 @@ use syn::visit_mut::VisitMut; use crate::parse_results::{MultiRunMetadata, get_or_append_run_metadata}; use crate::repair::{cycle_source_to_sink_input, inject_id, inject_location}; -use crate::rewrites::ClusterSelfIdReplace; +use crate::rewrites::{deserialize_bincode_with_type, serialize_bincode_with_type, ClusterSelfIdReplace}; #[derive(Clone, Serialize, Deserialize)] pub struct Decoupler { @@ -287,10 +284,12 @@ mod tests { use hydro_build_utils::insta; use hydro_deploy::Deployment; use hydro_lang::compile::builder::FlowBuilder; + use hydro_lang::compile::built::BuiltFlow; use hydro_lang::compile::ir; use hydro_lang::compile::rewrites::persist_pullup::persist_pullup; use hydro_lang::location::Location; use hydro_lang::nondet::nondet; + use hydro_lang::prelude::Cluster; use stageleft::q; use crate::debug::name_to_id_map; @@ -302,10 +301,10 @@ mod tests { output_to_original_machine_after: Vec<(&str, i32)>, place_on_decoupled_machine: Vec<(&str, i32)>, ) -> ( - hydro_lang::location::Cluster<'a, ()>, - hydro_lang::location::Cluster<'a, ()>, - hydro_lang::location::Cluster<'a, ()>, - hydro_lang::compile::built::BuiltFlow<'a>, + Cluster<'a, ()>, + Cluster<'a, ()>, + Cluster<'a, ()>, + BuiltFlow<'a>, ) { let builder = FlowBuilder::new(); let send_cluster = builder.cluster::<()>(); @@ -318,6 +317,8 @@ mod tests { .ir_node_named("map") .broadcast_bincode(&recv_cluster, nondet!(/** test */)) .values() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|a| println!("Got it: {}", a))); let multi_run_metadata = RefCell::new(vec![]); diff --git a/hydro_optimize/src/deploy_and_analyze.rs b/hydro_optimize/src/deploy_and_analyze.rs index 068c034..427f68d 100644 --- a/hydro_optimize/src/deploy_and_analyze.rs +++ b/hydro_optimize/src/deploy_and_analyze.rs @@ -36,6 +36,7 @@ fn insert_counter_node(node: &mut HydroNode, next_stmt_id: &mut usize, duration: | HydroNode::Persist { metadata, .. } | HydroNode::Delta { metadata, .. } | HydroNode::Chain { metadata, .. } // Can technically be derived by summing parent cardinalities + | HydroNode::ChainFirst { metadata, .. } // Can technically be derived by taking parent cardinality + 1 | HydroNode::CrossSingleton { metadata, .. } | HydroNode::CrossProduct { metadata, .. } // Can technically be derived by multiplying parent cardinalities | HydroNode::Join { metadata, .. } diff --git a/hydro_optimize/src/partition_node_analysis.rs b/hydro_optimize/src/partition_node_analysis.rs index a6a0e6c..1938bfa 100644 --- a/hydro_optimize/src/partition_node_analysis.rs +++ b/hydro_optimize/src/partition_node_analysis.rs @@ -190,7 +190,8 @@ fn input_dependency_analysis_node( } } // Alters parent in a predicatable way - HydroNode::Chain { .. } => { + HydroNode::Chain { .. } + | HydroNode::ChainFirst { .. } => { assert_eq!(parent_ids.len(), 2, "Node {:?} has the wrong number of parents.", node); // [a,b] chain [c,d] = [a,b,c,d]. Take the intersection of dependencies of the two parents for each input. If only one parent is tainted, then just take that dependency for (input_id, parent_positions) in parent_taints { @@ -538,10 +539,32 @@ fn partitioning_constraint_analysis_node( } HydroNode::Reduce { .. } | HydroNode::Fold { .. } + | HydroNode::Scan { .. } | HydroNode::Enumerate { .. } | HydroNode::CrossProduct { .. } | HydroNode::CrossSingleton { .. } => {} // Partitioning is impossible - _ => { + HydroNode::Placeholder + | HydroNode::Source { .. } + | HydroNode::CycleSource { .. } + | HydroNode::Tee { .. } + | HydroNode::Persist { .. } + | HydroNode::Unpersist { .. } + | HydroNode::Delta { .. } + | HydroNode::Chain { .. } + | HydroNode::ChainFirst { .. } + | HydroNode::ResolveFutures { .. } + | HydroNode::ResolveFuturesOrdered { .. } + | HydroNode::Map { .. } + | HydroNode::FlatMap { .. } + | HydroNode::Filter { .. } + | HydroNode::FilterMap { .. } + | HydroNode::DeferTick { .. } + | HydroNode::Inspect { .. } + | HydroNode::Unique { .. } + | HydroNode::Sort { .. } + | HydroNode::Network { .. } + | HydroNode::ExternalInput { .. } + | HydroNode::Counter { .. } => { // Doesn't impede partitioning, return return; } @@ -900,6 +923,8 @@ mod tests { .ir_node_named("the map following network") .map(q!(|(a, b)| (b, a + 2))) .ir_node_named("the operator being tested") + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|(b, a2)| { println!("b: {}, a+2: {}", b, a2); })); @@ -947,6 +972,8 @@ mod tests { .broadcast_bincode(&cluster2, nondet!(/** test */)) .values() .map(q!(|(a, b)| (b, a + 2))) + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|(b, a2)| { println!("b: {}, a+2: {}", b, a2); })); @@ -970,6 +997,8 @@ mod tests { .ir_node_named("map 1") .map(q!(|(b1, _a, b0a)| (b0a, b1.0))) .ir_node_named("map 2") + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|(b0a, b10)| { println!("b.0 - a: {}, b.1.0: {}", b0a, b10); })); @@ -1039,6 +1068,8 @@ mod tests { .ir_node_named("map after network") .filter_map(q!(|(a, b)| { if a > 1 { Some((b, a + 2)) } else { None } })) .ir_node_named("operator") + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|(b, a2)| { println!("b: {}, a+2: {}", b, a2); })); @@ -1097,6 +1128,8 @@ mod tests { } })) .ir_node_named("operator") + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|(none, a2)| { println!("None: {:?}, a+2: {}", none, a2); })); @@ -1126,73 +1159,6 @@ mod tests { ); } - #[test] - fn test_delta() { - let builder = FlowBuilder::new(); - let cluster1 = builder.cluster::<()>(); - let cluster2 = builder.cluster::<()>(); - cluster1 - .source_iter(q!([(1, 2)])) - .broadcast_bincode(&cluster2, nondet!(/** test */)) - .ir_node_named("network") - .values() - .ir_node_named("map after network") - .batch(&cluster2.tick(), nondet!(/** test */)) - .delta() - .ir_node_named("operator") - .all_ticks() - .for_each(q!(|(a, b)| { - println!("a: {}, b: {}", a, b); - })); - - let expected_taint = BTreeMap::from([ - ("map after network", BTreeSet::from(["network"])), - ("operator", BTreeSet::from(["network"])), - ]); - - let mut implicit_map_dependencies = StructOrTuple::default(); - implicit_map_dependencies.add_dependency(&vec![], vec!["1".to_string()]); - - let expected_dependencies = BTreeMap::from([ - ("network", BTreeMap::new()), - ( - "map after network", - BTreeMap::from([("network", implicit_map_dependencies.clone())]), - ), - ( - "operator", - BTreeMap::from([("network", implicit_map_dependencies)]), - ), // No dependency changes from parent - ]); - - test_input( - builder, - cluster2.id(), - expected_taint, - expected_dependencies, - ); - } - - #[test] - fn test_delta_partitionable() { - let builder = FlowBuilder::new(); - let cluster1 = builder.cluster::<()>(); - let cluster2 = builder.cluster::<()>(); - cluster1 - .source_iter(q!([(1, 2)])) - .broadcast_bincode(&cluster2, nondet!(/** test */)) - .values() - .batch(&cluster2.tick(), nondet!(/** test */)) - .delta() - .all_ticks() - .for_each(q!(|(a, b)| { - println!("a: {}, b: {}", a, b); - })); - - let expected_partitionings = Some(Vec::new()); // No partitioning constraints - test_input_partitionable(builder, cluster2.id(), expected_partitionings); - } - #[test] fn test_chain() { let builder = FlowBuilder::new(); @@ -1219,6 +1185,8 @@ mod tests { .chain(stream1.batch(&tick, nondet!(/** test */))) .ir_node_named("chain") .all_ticks() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|((x, b1), y)| { println!("x: {}, b.1: {}, y: {}", x, b1, y); })); @@ -1303,6 +1271,8 @@ mod tests { .batch(&tick, nondet!(/** test */)) .chain(stream1.batch(&tick, nondet!(/** test */))) .all_ticks() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|((x, b1), y)| { println!("x: {}, b.1: {}, y: {}", x, b1, y); })); @@ -1337,6 +1307,8 @@ mod tests { .cross_product(stream1.batch(&tick, nondet!(/** test */))) .ir_node_named("cross product") .all_ticks() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|(((b1, b1_again), a3), (b, a2))| { println!("((({}, {}), {}), ({:?}, {}))", b1, b1_again, a3, b, a2); })); @@ -1432,6 +1404,8 @@ mod tests { .batch(&tick, nondet!(/** test */)) .cross_product(stream1.batch(&tick, nondet!(/** test */))) .all_ticks() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|(((b1, b1_again), a3), (b, a2))| { println!("((({}, {}), {}), ({:?}, {}))", b1, b1_again, a3, b, a2); })); @@ -1466,6 +1440,8 @@ mod tests { .join(stream1.batch(&tick, nondet!(/** test */))) .ir_node_named("join") .all_ticks() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|((b1, b1_again), (a3, a))| { println!("(({}, {}), {}, {})", b1, b1_again, a3, a); })); @@ -1571,6 +1547,8 @@ mod tests { .batch(&tick, nondet!(/** test */)) .join(stream1.batch(&tick, nondet!(/** test */))) .all_ticks() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|((b1, b1_again), (a3, a))| { println!("(({}, {}), {}, {})", b1, b1_again, a3, a); })); @@ -1677,6 +1655,8 @@ mod tests { .ir_node_named("reduce keyed") .entries() .all_ticks() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|(a, b_sum)| { println!("a: {}, b_sum: {}", a, b_sum); })); @@ -1729,6 +1709,8 @@ mod tests { .reduce_commutative(q!(|acc, b| *acc += b)) .entries() .all_ticks() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|(a, b_sum)| { println!("a: {}, b_sum: {}", a, b_sum); })); @@ -1839,6 +1821,8 @@ mod tests { cycle .ir_node_named("teed cycle 2") .all_ticks() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|(a, b)| { println!("a: {}, b: {}", a, b); })); @@ -1934,9 +1918,13 @@ mod tests { prev_tick_input.chain(input.batch(&cluster2_tick, nondet!(/** test */))), ); - cycle.all_ticks().for_each(q!(|(a, b)| { - println!("a: {}, b: {}", a, b); - })); + cycle + .all_ticks() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) + .for_each(q!(|(a, b)| { + println!("a: {}, b: {}", a, b); + })); let expected_partitionings = Some(Vec::new()); test_input_partitionable(builder, cluster2.id(), expected_partitionings); @@ -1979,6 +1967,8 @@ mod tests { cycle2_out .ir_node_named("teed map (a,b) to (b,b) 2") .all_ticks() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|(b, _)| { println!("b: {}", b); })); @@ -2128,7 +2118,8 @@ mod tests { complete_cycle1.complete_next_tick(chained.clone()); let cycle2_out = chained.map(q!(|(_a, b)| (b, b))); complete_cycle2.complete_next_tick(cycle2_out.clone()); - cycle2_out.all_ticks().for_each(q!(|(b, _)| { + cycle2_out.all_ticks().assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)).for_each(q!(|(b, _)| { println!("b: {}", b); })); @@ -2160,6 +2151,8 @@ mod tests { .chain(stream1.batch(&tick, nondet!(/** test */))) .ir_node_named("chain") .all_ticks() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|_| { println!("No dependencies"); })); @@ -2221,6 +2214,8 @@ mod tests { .batch(&tick, nondet!(/** test */)) .chain(stream1.batch(&tick, nondet!(/** test */))) .all_ticks() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|_| { println!("No dependencies"); })); @@ -2259,6 +2254,8 @@ mod tests { .chain(stream1.clone().ir_node_named("teed map1 1")) .ir_node_named("chain") .all_ticks() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|_| { println!("Dependent on both input1.b and input2.b"); })); @@ -2267,6 +2264,8 @@ mod tests { .join(stream1.ir_node_named("teed map1 2")) .ir_node_named("join") .all_ticks() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|(_, (b1, b2))| { println!("b from input 1: {}, b from input 2: {}", b1, b2); })); @@ -2393,12 +2392,16 @@ mod tests { .clone() .chain(stream1.clone()) .all_ticks() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|_| { println!("Dependent on both input1.b and input2.b"); })); stream2 .join(stream1) .all_ticks() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|(_, (a1, a2))| { println!("a*2 from input 1: {}, -a from input 2: {}", a1, a2); })); @@ -2433,6 +2436,8 @@ mod tests { .filter_not_in(input2.batch(&tick, nondet!(/** test */))) .ir_node_named("difference") .all_ticks() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|(a, b)| { println!("a: {}, b: {}", a, b); })); @@ -2491,6 +2496,8 @@ mod tests { .batch(&tick, nondet!(/** test */)) .filter_not_in(input2.batch(&tick, nondet!(/** test */))) .all_ticks() + .assume_ordering(nondet!(/** test */)) + .assume_retries(nondet!(/** test */)) .for_each(q!(|(a, b)| { println!("a: {}, b: {}", a, b); })); diff --git a/hydro_optimize/src/partitioner.rs b/hydro_optimize/src/partitioner.rs index 3dc1cea..b11b91e 100644 --- a/hydro_optimize/src/partitioner.rs +++ b/hydro_optimize/src/partitioner.rs @@ -2,16 +2,13 @@ use core::panic; use std::collections::HashMap; use hydro_lang::compile::ir::{HydroNode, HydroRoot, traverse_dfir}; -use hydro_lang::live_collections::stream::networking::{ - deserialize_bincode_with_type, serialize_bincode_with_type, -}; use hydro_lang::location::dynamic::LocationId; use serde::{Deserialize, Serialize}; use syn::visit_mut::{self, VisitMut}; use crate::partition_syn_analysis::StructOrTupleIndex; use crate::repair::inject_id; -use crate::rewrites::{ClusterSelfIdReplace, NetworkType, get_network_type}; +use crate::rewrites::{deserialize_bincode_with_type, get_network_type, serialize_bincode_with_type, ClusterSelfIdReplace, NetworkType}; #[derive(Clone, Serialize, Deserialize)] pub struct Partitioner { diff --git a/hydro_optimize/src/rewrites.rs b/hydro_optimize/src/rewrites.rs index a3f6a3d..274b80e 100644 --- a/hydro_optimize/src/rewrites.rs +++ b/hydro_optimize/src/rewrites.rs @@ -6,7 +6,10 @@ use hydro_lang::compile::ir::{HydroIrMetadata, HydroNode, HydroRoot, deep_clone, use hydro_lang::location::dynamic::LocationId; use hydro_lang::location::{Cluster, Location}; use serde::{Deserialize, Serialize}; +use syn::parse_quote; use syn::visit_mut::{self, VisitMut}; +use proc_macro2::{Span, TokenStream}; +use quote::quote; use crate::decoupler::{self, Decoupler}; use crate::partitioner::Partitioner; @@ -200,3 +203,56 @@ pub fn get_network_type(node: &HydroNode, location: usize) -> Option TokenStream { + let hydro_lang_crate = proc_macro_crate::crate_name("hydro_lang") + .expect("hydro_lang should be present in `Cargo.toml`"); + match hydro_lang_crate { + proc_macro_crate::FoundCrate::Itself => quote! { hydro_lang }, + proc_macro_crate::FoundCrate::Name(name) => { + let ident = syn::Ident::new(&name, Span::call_site()); + quote! { #ident } + } + } +} + +pub fn serialize_bincode_with_type(is_demux: bool, t_type: &syn::Type) -> syn::Expr { + let root = get_this_crate(); + + if is_demux { + parse_quote! { + ::#root::runtime_support::stageleft::runtime_support::fn1_type_hint::<(#root::location::MemberId<_>, #t_type), _>( + |(id, data)| { + (id.raw_id, #root::runtime_support::bincode::serialize(&data).unwrap().into()) + } + ) + } + } else { + parse_quote! { + ::#root::runtime_support::stageleft::runtime_support::fn1_type_hint::<#t_type, _>( + |data| { + #root::runtime_support::bincode::serialize(&data).unwrap().into() + } + ) + } + } +} + +pub fn deserialize_bincode_with_type(tagged: Option<&syn::Type>, t_type: &syn::Type) -> syn::Expr { + let root = get_this_crate(); + + if let Some(c_type) = tagged { + parse_quote! { + |res| { + let (id, b) = res.unwrap(); + (#root::location::MemberId::<#c_type>::from_raw(id), #root::runtime_support::bincode::deserialize::<#t_type>(&b).unwrap()) + } + } + } else { + parse_quote! { + |res| { + #root::runtime_support::bincode::deserialize::<#t_type>(&res.unwrap()).unwrap() + } + } + } +} \ No newline at end of file diff --git a/hydro_optimize_examples/Cargo.toml b/hydro_optimize_examples/Cargo.toml index 32792ed..342f76c 100644 --- a/hydro_optimize_examples/Cargo.toml +++ b/hydro_optimize_examples/Cargo.toml @@ -8,24 +8,24 @@ edition = "2024" all-features = true [dependencies] -hydro_lang = { git = "https://github.com/hydro-project/hydro.git" } -hydro_std = { git = "https://github.com/hydro-project/hydro.git" } -hydro_test = { git = "https://github.com/hydro-project/hydro.git" } -serde = { version = "1.0.197", features = ["derive"] } +hydro_lang.workspace = true +hydro_std.workspace = true +hydro_test.workspace = true +serde.workspace = true sha2 = "0.10.9" -stageleft = "0.9.7" -tokio = { version = "1.29.0", features = ["full"] } +stageleft.workspace = true +tokio.workspace = true [dev-dependencies] -ctor = "0.2" -clap = { version = "4.4", features = ["derive"] } -dfir_lang = { git = "https://github.com/hydro-project/hydro.git" } -hydro_build_utils = { git = "https://github.com/hydro-project/hydro.git", version = "0.0.1" } -hydro_deploy = { git = "https://github.com/hydro-project/hydro.git" } -hydro_lang = { git = "https://github.com/hydro-project/hydro.git", features = ["deploy", "viz"] } +ctor.workspace = true +clap.workspace = true +dfir_lang.workspace = true +hydro_build_utils.workspace = true +hydro_deploy.workspace = true +hydro_lang = { workspace = true, features = ["deploy", "viz"] } hydro_optimize = { path = "../hydro_optimize" } -regex = "1.11.1" +regex.workspace = true [build-dependencies] -stageleft_tool = "0.9.7" -hydro_build_utils = { git = "https://github.com/hydro-project/hydro.git", version = "0.0.1" } \ No newline at end of file +stageleft_tool.workspace = true +hydro_build_utils.workspace = true \ No newline at end of file diff --git a/hydro_optimize_examples/src/simple_graphs.rs b/hydro_optimize_examples/src/simple_graphs.rs index b550336..7a464ee 100644 --- a/hydro_optimize_examples/src/simple_graphs.rs +++ b/hydro_optimize_examples/src/simple_graphs.rs @@ -28,13 +28,17 @@ impl<'a, F> GraphFunction<'a> for F where } fn sha256(n: u32) -> u32 { + let start_time = std::time::Instant::now(); let mut sha_input = n; - for _ in 0..n { + loop { let mut sha = Sha256::new(); sha.update(sha_input.to_be_bytes()); let sha_output = sha.finalize(); sha_input = sha_output[0].into(); + if start_time.elapsed().as_micros() >= n.into() { + break; + } } sha_input diff --git a/hydro_optimize_examples/src/simple_kv_bench.rs b/hydro_optimize_examples/src/simple_kv_bench.rs index 89aaa1b..da8e1f9 100644 --- a/hydro_optimize_examples/src/simple_kv_bench.rs +++ b/hydro_optimize_examples/src/simple_kv_bench.rs @@ -37,6 +37,8 @@ pub fn simple_kv_bench<'a>( })) .entries() .all_ticks() + .assume_ordering(nondet!(/** for_each does nothing, just need to end on a HydroLeaf */)) + .assume_retries(nondet!(/** for_each does nothing, just need to end on a HydroLeaf */)) .for_each(q!(|_| {})); // Do nothing, just need to end on a HydroLeaf // Send committed requests back to the original client diff --git a/hydro_optimize_examples/src/web_submit.rs b/hydro_optimize_examples/src/web_submit.rs index 61d216b..2ba935b 100644 --- a/hydro_optimize_examples/src/web_submit.rs +++ b/hydro_optimize_examples/src/web_submit.rs @@ -114,6 +114,8 @@ pub fn web_submit<'a, Client>( users_this_tick_with_api_key .clone() .all_ticks() + .assume_ordering(nondet!(/** Email order doesn't matter */)) + .assume_retries(nondet!(/** At least once delivery is fine */)) .for_each(q!(|(_client_id, (email, _is_admin, api_key))| { self::send_email(api_key, email) })); From 9a6f6ff8c220ad9919f72357e9878ac0895a4fc5 Mon Sep 17 00:00:00 2001 From: David Chu Date: Tue, 23 Sep 2025 00:19:46 +0000 Subject: [PATCH 04/35] Fixes for cases where no send/recv overhead is recorded, added noop experiment --- hydro_optimize/src/deploy_and_analyze.rs | 4 ++-- hydro_optimize/src/parse_results.rs | 4 ++-- hydro_optimize_examples/src/simple_graphs.rs | 8 ++++++++ 3 files changed, 12 insertions(+), 4 deletions(-) diff --git a/hydro_optimize/src/deploy_and_analyze.rs b/hydro_optimize/src/deploy_and_analyze.rs index 427f68d..46e14d8 100644 --- a/hydro_optimize/src/deploy_and_analyze.rs +++ b/hydro_optimize/src/deploy_and_analyze.rs @@ -216,8 +216,8 @@ pub async fn deploy_and_analyze<'a>( // Create a mapping from each CycleSink to its corresponding CycleSource let cycle_source_to_sink_input = cycle_source_to_sink_input(&mut ir); analyze_send_recv_overheads(&mut ir, run_metadata); - let send_overhead = *run_metadata.send_overhead.get(&bottleneck).unwrap(); - let recv_overhead = *run_metadata.recv_overhead.get(&bottleneck).unwrap(); + let send_overhead = run_metadata.send_overhead.get(&bottleneck).cloned().unwrap_or_default(); + let recv_overhead = run_metadata.recv_overhead.get(&bottleneck).cloned().unwrap_or_default(); // Check the expected/actual CPU usages before/after rewrites std::mem::drop(mut_multi_run_metadata); // Release borrow diff --git a/hydro_optimize/src/parse_results.rs b/hydro_optimize/src/parse_results.rs index 2b0e557..741f3ce 100644 --- a/hydro_optimize/src/parse_results.rs +++ b/hydro_optimize/src/parse_results.rs @@ -589,7 +589,7 @@ pub fn compare_expected_performance( { compare_expected_values( cpu_usage, - prev_run_metadata.send_overhead.get(prev_location).unwrap() + prev_run_metadata.send_overhead.get(prev_location).cloned().unwrap_or_default() * *prev_cardinality as f64, location, prev_location, @@ -605,7 +605,7 @@ pub fn compare_expected_performance( { compare_expected_values( cpu_usage, - prev_run_metadata.recv_overhead.get(prev_location).unwrap() + prev_run_metadata.recv_overhead.get(prev_location).cloned().unwrap_or_default() * *prev_cardinality as f64, &location, prev_location, diff --git a/hydro_optimize_examples/src/simple_graphs.rs b/hydro_optimize_examples/src/simple_graphs.rs index 7a464ee..08fbb98 100644 --- a/hydro_optimize_examples/src/simple_graphs.rs +++ b/hydro_optimize_examples/src/simple_graphs.rs @@ -48,6 +48,7 @@ fn sha256(n: u32) -> u32 { pub fn get_graph_function<'a>(name: &str) -> impl GraphFunction<'a> { match name { + "noop" => noop, "map_h_map_h_map_h" => map_h_map_h_map_h, "map_h_map_h_map_l" => map_h_map_h_map_l, "map_h_map_l_map_h" => map_h_map_l_map_h, @@ -84,6 +85,13 @@ pub fn get_graph_function<'a>(name: &str) -> impl GraphFunction<'a> { } } +pub fn noop<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + payloads +} + pub fn map_h_map_h_map_h<'a>( _server: &Cluster<'a, Server>, payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, From 4ea9bcf1918c053a4920d944068fd14ab70a6fc2 Mon Sep 17 00:00:00 2001 From: David Chu Date: Mon, 27 Oct 2025 23:13:26 +0000 Subject: [PATCH 05/35] Adopting changes HydroNode, HydroRoot, and HydroIrMetadata. WIP --- hydro_optimize/src/partitioner.rs | 54 ++++++++++++++---------------- hydro_optimize/src/repair.rs | 54 ++++++++++-------------------- hydro_optimize/src/rewrites.rs | 19 ++++++++++- hydro_optimize/src/tests/mod.rs | 3 -- hydro_optimize/src/tests/two_pc.rs | 3 -- 5 files changed, 62 insertions(+), 71 deletions(-) diff --git a/hydro_optimize/src/partitioner.rs b/hydro_optimize/src/partitioner.rs index b11b91e..4c427ae 100644 --- a/hydro_optimize/src/partitioner.rs +++ b/hydro_optimize/src/partitioner.rs @@ -1,14 +1,15 @@ use core::panic; use std::collections::HashMap; -use hydro_lang::compile::ir::{HydroNode, HydroRoot, traverse_dfir}; +use hydro_lang::compile::ir::{BoundKind, CollectionKind, DebugType, HydroNode, HydroRoot, KeyedSingletonBoundKind, StreamOrder, StreamRetry, traverse_dfir}; +use hydro_lang::live_collections::keyed_singleton::KeyedSingletonBound; use hydro_lang::location::dynamic::LocationId; use serde::{Deserialize, Serialize}; use syn::visit_mut::{self, VisitMut}; use crate::partition_syn_analysis::StructOrTupleIndex; use crate::repair::inject_id; -use crate::rewrites::{deserialize_bincode_with_type, get_network_type, serialize_bincode_with_type, ClusterSelfIdReplace, NetworkType}; +use crate::rewrites::{ClusterSelfIdReplace, NetworkType, collection_kind_to_debug_type, deserialize_bincode_with_type, get_network_type, serialize_bincode_with_type}; #[derive(Clone, Serialize, Deserialize)] pub struct Partitioner { @@ -125,11 +126,29 @@ fn replace_sender_dest(node: &mut HydroNode, partitioner: &Partitioner, next_stm let f: syn::Expr = if new_cluster_id.is_some() { // Output type of Map now includes dest ID - let original_output_type = *metadata.output_type.clone().unwrap().0; - let new_output_type: syn::Type = syn::parse_quote! { - (::hydro_lang::location::MemberId<()>, #original_output_type) + let member_id_syn_type: syn::Type = syn::parse_quote! { ::hydro_lang::location::MemberId<()> }; + let member_id_debug_type = DebugType::from(member_id_syn_type); + metadata.collection_kind = match metadata.collection_kind { + CollectionKind::Singleton { element_type, .. } + | CollectionKind::Optional { element_type, .. } => { + CollectionKind::KeyedSingleton { + bound: KeyedSingletonBoundKind::Unbounded, + key_type: member_id_debug_type, + value_type: element_type, + } + } + CollectionKind::Stream { .. } + | CollectionKind::KeyedStream { .. } + | CollectionKind::KeyedSingleton { .. } => { + CollectionKind::KeyedStream { + bound: BoundKind::Unbounded, + value_order: StreamOrder::NoOrder, + value_retry: StreamRetry::ExactlyOnce, + key_type: member_id_debug_type, + value_type: collection_kind_to_debug_type(&metadata.collection_kind), + } + } }; - metadata.output_type = Some(new_output_type.into()); // Partitioning a process into a cluster syn::parse_quote!( @@ -220,7 +239,7 @@ fn replace_network_serialization(node: &mut HydroNode, partitioner: &Partitioner panic!("Expected a HydroNode::Network, but found {:?}", node); }; - let output_type = metadata.output_type.clone().unwrap().0; + let output_type = collection_kind_to_debug_type(&metadata.collection_kind); // The partitioned process (now cluster) is the sender // Its ID will now be in the recipient's output, so change the deserialize fn @@ -321,22 +340,6 @@ fn replace_process_node_location(node: &mut HydroNode, partitioner: &Partitioner } } -/// If we're partitioning a process into a cluster, we need to replace references to its location -fn replace_process_root_location(root: &mut HydroRoot, partitioner: &Partitioner) { - let Partitioner { - location_id, - new_cluster_id, - .. - } = partitioner; - - if let Some(new_id) = new_cluster_id { - // Modify the metadata - if let HydroRoot::CycleSink { out_location, .. } = root { - replace_process_location_id(out_location, *location_id, *new_id); - } - } -} - /// If we're partitioning a process into a cluster, we need to remove the default sender ID on outgoing networks fn remove_sender_id_from_receiver(node: &mut HydroNode, partitioner: &Partitioner, op_id: usize) { let Partitioner { new_cluster_id, .. } = partitioner; @@ -383,11 +386,6 @@ pub fn partition(ir: &mut [HydroRoot], partitioner: &Partitioner) { ); if partitioner.new_cluster_id.is_some() { - // Separately traverse roots since CycleSink isn't processed in traverse_dfir - for root in ir.iter_mut() { - replace_process_root_location(root, partitioner); - } - // DANGER: Do not depend on the ID here, since nodes would've been injected // Fix network only after all IDs have been replaced, since get_network_type relies on it traverse_dfir( diff --git a/hydro_optimize/src/repair.rs b/hydro_optimize/src/repair.rs index fb1f51a..776c1f6 100644 --- a/hydro_optimize/src/repair.rs +++ b/hydro_optimize/src/repair.rs @@ -84,24 +84,6 @@ pub fn cycle_source_to_sink_input(ir: &mut [HydroRoot]) -> HashMap source_to_sink_input } -fn inject_location_root( - root: &mut HydroRoot, - id_to_location: &RefCell>, - missing_location: &RefCell, -) { - let inputs = root.input_metadata(); - let input_metadata = inputs.first().unwrap(); - - if let Some(location) = id_to_location.borrow().get(&input_metadata.op.id.unwrap()) { - if let HydroRoot::CycleSink { out_location, .. } = root { - out_location.swap_root(location.root().clone()); - } - } else { - println!("Missing location for root: {:?}", root.print_root()); - *missing_location.borrow_mut() = true; - } -} - fn inject_location_input_persist(input: &mut Box, new_location: LocationId) { if let HydroNode::Persist { metadata: persist_metadata, @@ -112,22 +94,22 @@ fn inject_location_input_persist(input: &mut Box, new_location: Locat } } +// Returns whether location was missing for any node and requires another round of calculation (to reach fixpoint) fn inject_location_node( node: &mut HydroNode, - id_to_location: &RefCell>, - missing_location: &RefCell, + id_to_location: &mut HashMap, cycle_source_to_sink_input: &HashMap, -) { +) -> bool { if let Some(op_id) = node.op_metadata().id { let inputs = match node { HydroNode::Source { metadata, .. } + | HydroNode::SingletonSource { metadata, .. } | HydroNode::ExternalInput { metadata, .. } | HydroNode::Network { metadata, .. } => { // Get location sources from the nodes must have it be correct: Source and Network id_to_location - .borrow_mut() .insert(op_id, metadata.location_kind.clone()); - return; + return false; } HydroNode::Tee { inner, .. } => { vec![inner.0.borrow().op_metadata().id.unwrap()] @@ -145,11 +127,10 @@ fn inject_location_node( // Otherwise, get it from (either) input let metadata = node.metadata_mut(); for input in inputs { - let location = id_to_location.borrow().get(&input).cloned(); + let location = id_to_location.get(&input).cloned(); if let Some(location) = location { metadata.location_kind.swap_root(location.root().clone()); id_to_location - .borrow_mut() .insert(op_id, metadata.location_kind.clone()); match node { @@ -168,45 +149,46 @@ fn inject_location_node( | HydroNode::FoldKeyed { input, .. } | HydroNode::Reduce { input, .. } | HydroNode::ReduceKeyed { input, .. } + | HydroNode::ReduceKeyedWatermark { input, .. } | HydroNode::Scan { input, .. } => { inject_location_input_persist(input, location.root().clone()); } _ => {} } - return; + return false; } } // If the location was not set, let the recursive function know println!("Missing location for node: {:?}", node.print_root()); - *missing_location.borrow_mut() = true; + return true; } + + // No op_id, probably can ignore? + return false; } pub fn inject_location(ir: &mut [HydroRoot], cycle_source_to_sink_input: &HashMap) { - let id_to_location = RefCell::new(HashMap::new()); + let mut id_to_location = HashMap::new(); loop { println!("Attempting to inject location, looping until fixpoint..."); - let missing_location = RefCell::new(false); + let mut missing_location = false; transform_bottom_up( ir, - &mut |leaf| { - inject_location_root(leaf, &id_to_location, &missing_location); - }, + &mut |_| {}, &mut |node| { - inject_location_node( + missing_location |= inject_location_node( node, - &id_to_location, - &missing_location, + &mut id_to_location, cycle_source_to_sink_input, ); }, false, ); - if !*missing_location.borrow() { + if !missing_location { println!("Locations injected!"); // Check well-formedness here diff --git a/hydro_optimize/src/rewrites.rs b/hydro_optimize/src/rewrites.rs index 274b80e..a53c86b 100644 --- a/hydro_optimize/src/rewrites.rs +++ b/hydro_optimize/src/rewrites.rs @@ -2,7 +2,7 @@ use std::cell::RefCell; use std::collections::HashMap; use hydro_lang::compile::builder::{FlowBuilder, RewriteIrFlowBuilder}; -use hydro_lang::compile::ir::{HydroIrMetadata, HydroNode, HydroRoot, deep_clone, traverse_dfir}; +use hydro_lang::compile::ir::{CollectionKind, DebugType, HydroIrMetadata, HydroNode, HydroRoot, deep_clone, traverse_dfir}; use hydro_lang::location::dynamic::LocationId; use hydro_lang::location::{Cluster, Location}; use serde::{Deserialize, Serialize}; @@ -255,4 +255,21 @@ pub fn deserialize_bincode_with_type(tagged: Option<&syn::Type>, t_type: &syn::T } } } +} + +pub fn collection_kind_to_debug_type(collection_kind: &CollectionKind) -> DebugType { + match collection_kind { + CollectionKind::Stream { element_type, .. } + | CollectionKind::Singleton { element_type, .. } + | CollectionKind::Optional { element_type, .. } => DebugType::from(*element_type.clone().0), + CollectionKind::KeyedStream { key_type, value_type, .. } + | CollectionKind::KeyedSingleton { key_type, value_type, .. } => { + let original_key_type = *key_type.clone().0; + let original_value_type = *value_type.clone().0; + let new_type: syn::Type = syn::parse_quote! { + (#original_key_type, #original_value_type) + }; + DebugType::from(new_type) + } + } } \ No newline at end of file diff --git a/hydro_optimize/src/tests/mod.rs b/hydro_optimize/src/tests/mod.rs index 9d3d091..51563ce 100644 --- a/hydro_optimize/src/tests/mod.rs +++ b/hydro_optimize/src/tests/mod.rs @@ -2,7 +2,6 @@ use std::cell::RefCell; use std::collections::HashMap; use hydro_build_utils::insta; -use hydro_lang::compile::rewrites::persist_pullup; use hydro_lang::deploy::HydroDeploy; use hydro_lang::location::Location; use hydro_lang::prelude::*; @@ -28,7 +27,6 @@ fn decoupled_compute_pi_ir() { }; let multi_run_metadata = RefCell::new(vec![]); let built = builder - .optimize_with(persist_pullup::persist_pullup) .optimize_with(|roots| decoupler::decouple(roots, &decoupler, &multi_run_metadata, 0)) .into_deploy::(); @@ -54,7 +52,6 @@ fn partitioned_simple_cluster_ir() { new_cluster_id: None, }; let built = builder - .optimize_with(persist_pullup::persist_pullup) .optimize_with(|roots| crate::partitioner::partition(roots, &partitioner)) .into_deploy::(); diff --git a/hydro_optimize/src/tests/two_pc.rs b/hydro_optimize/src/tests/two_pc.rs index c6cab70..dc30513 100644 --- a/hydro_optimize/src/tests/two_pc.rs +++ b/hydro_optimize/src/tests/two_pc.rs @@ -2,7 +2,6 @@ use std::collections::{BTreeMap, HashMap}; use hydro_build_utils::insta; use hydro_lang::compile::ir::deep_clone; -use hydro_lang::compile::rewrites::persist_pullup::persist_pullup; use hydro_lang::deploy::HydroDeploy; use hydro_lang::location::Location; use hydro_lang::prelude::*; @@ -45,7 +44,6 @@ fn two_pc_partition_coordinator() { let mut cycle_data = HashMap::new(); let built = builder - .optimize_with(persist_pullup) .optimize_with(|ir| { inject_id(ir); cycle_data = cycle_source_to_sink_input(ir); @@ -101,7 +99,6 @@ fn two_pc_partition_participant() { let mut cycle_data = HashMap::new(); let built = builder - .optimize_with(persist_pullup) .optimize_with(|ir| { inject_id(ir); cycle_data = cycle_source_to_sink_input(ir); From 4d09fa8393362b903ead703fd7351a0b8a241809 Mon Sep 17 00:00:00 2001 From: David Chu Date: Mon, 27 Oct 2025 23:59:07 +0000 Subject: [PATCH 06/35] Fixed compile-time errors --- Cargo.lock | 50 ++++++++++++++++--- Cargo.toml | 4 +- hydro_optimize/src/decoupler.rs | 31 ++++++------ hydro_optimize/src/deploy_and_analyze.rs | 12 +++-- hydro_optimize/src/partition_node_analysis.rs | 27 ++++++---- hydro_optimize/src/partitioner.rs | 29 ++--------- hydro_optimize/src/rewrites.rs | 30 ++++++++++- .../examples/benchmark_paxos.rs | 2 +- .../examples/decouple_compute_pi.rs | 4 +- .../examples/partition_simple_cluster.rs | 4 +- .../examples/partition_two_pc.rs | 2 - .../examples/perf_compute_pi.rs | 2 +- .../examples/perf_paxos.rs | 2 +- .../examples/simple_graphs.rs | 2 +- 14 files changed, 123 insertions(+), 78 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 972763a..4b38acb 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -91,6 +91,12 @@ dependencies = [ "alloc-no-stdlib", ] +[[package]] +name = "allocator-api2" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" + [[package]] name = "android_system_properties" version = "0.1.5" @@ -1589,6 +1595,10 @@ name = "hashbrown" version = "0.14.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" +dependencies = [ + "ahash", + "allocator-api2", +] [[package]] name = "hashbrown" @@ -1754,6 +1764,7 @@ dependencies = [ "futures", "pin-project-lite", "serde", + "sinktools", "tempfile", "tokio", "tokio-stream", @@ -1772,6 +1783,7 @@ dependencies = [ "ctor 0.2.9", "data-encoding", "dfir_lang", + "flate2", "futures", "hydro_build_utils", "hydro_deploy", @@ -1795,6 +1807,7 @@ dependencies = [ "tokio-util", "toml", "trybuild-internals-api", + "urlencoding", "webbrowser", ] @@ -3954,6 +3967,16 @@ version = "2.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa" +[[package]] +name = "sinktools" +version = "0.0.1" +dependencies = [ + "futures-util", + "pin-project-lite", + "sealed", + "variadics", +] + [[package]] name = "siphasher" version = "1.0.1" @@ -4067,9 +4090,9 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" [[package]] name = "stageleft" -version = "0.9.7" +version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "54b1cbaa5d12efbc7445d148e28befd36da1417276fe7a786cf602af1e63ee89" +checksum = "b92cb4d28ec3c2b3aba8ee05487f10c3aa00d7a369a3fe9d4d89e8719f28ca4f" dependencies = [ "ctor 0.4.3", "proc-macro-crate", @@ -4081,9 +4104,9 @@ dependencies = [ [[package]] name = "stageleft_macro" -version = "0.9.7" +version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "693fb6c3ec9a968373bc7f62aff4327bd143ffdfe952f02212e4ea75f60ca1f3" +checksum = "e05624677c37d2abebe0c3e50fa7722f99936d26de2a8a23ac5d2a397be596c0" dependencies = [ "proc-macro-crate", "proc-macro2", @@ -4094,9 +4117,9 @@ dependencies = [ [[package]] name = "stageleft_tool" -version = "0.9.7" +version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "18b040a605df7aade9cc7a1ec11bd996adbebde50df78f7ae3e1bf021050288c" +checksum = "da14207006ed0031a24197e0a2d3bc84b2a7ecf3a2ca70b70f1886cf1a37b464" dependencies = [ "prettyplease", "proc-macro-crate", @@ -4622,6 +4645,12 @@ dependencies = [ "serde", ] +[[package]] +name = "urlencoding" +version = "2.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da" + [[package]] name = "utf8_iter" version = "1.0.4" @@ -4644,6 +4673,15 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "variadics" +version = "0.0.9" +dependencies = [ + "hashbrown 0.14.5", + "hydro_build_utils", + "sealed", +] + [[package]] name = "version_check" version = "0.9.5" diff --git a/Cargo.toml b/Cargo.toml index 8b129b8..23fed39 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,8 +16,8 @@ hydro_build_utils = { path = "../hydroflow/hydro_build_utils" } hydro_deploy = { path = "../hydroflow/hydro_deploy/core" } include_mdtests = { path = "../hydroflow/include_mdtests" } serde = { version = "1.0.197", features = ["derive"] } -stageleft = "0.9.7" -stageleft_tool = "0.9.7" +stageleft = "0.10.0" +stageleft_tool = "0.10.0" tokio = { version = "1.29.0", features = ["full"] } ctor = "0.2" clap = { version = "4.4", features = ["derive"] } diff --git a/hydro_optimize/src/decoupler.rs b/hydro_optimize/src/decoupler.rs index e7d6cd4..7af2e3f 100644 --- a/hydro_optimize/src/decoupler.rs +++ b/hydro_optimize/src/decoupler.rs @@ -3,10 +3,9 @@ use std::collections::HashMap; use std::rc::Rc; use hydro_lang::compile::ir::{ - DebugInstantiate, DebugType, HydroIrMetadata, HydroIrOpMetadata, HydroNode, HydroRoot, TeeNode, + DebugInstantiate, HydroIrMetadata, HydroIrOpMetadata, HydroNode, HydroRoot, TeeNode, transform_bottom_up, traverse_dfir, }; -use hydro_lang::location::MemberId; use hydro_lang::location::dynamic::LocationId; use proc_macro2::Span; use serde::{Deserialize, Serialize}; @@ -15,7 +14,7 @@ use syn::visit_mut::VisitMut; use crate::parse_results::{MultiRunMetadata, get_or_append_run_metadata}; use crate::repair::{cycle_source_to_sink_input, inject_id, inject_location}; -use crate::rewrites::{deserialize_bincode_with_type, serialize_bincode_with_type, ClusterSelfIdReplace}; +use crate::rewrites::{ClusterSelfIdReplace, collection_kind_to_debug_type, deserialize_bincode_with_type, prepend_member_id_to_collection_kind, serialize_bincode_with_type}; #[derive(Clone, Serialize, Deserialize)] pub struct Decoupler { @@ -28,8 +27,6 @@ pub struct Decoupler { fn add_network(node: &mut HydroNode, new_location: &LocationId) { let metadata = node.metadata().clone(); - let output_debug_type = metadata.output_type.clone().unwrap(); - let parent_id = metadata.location_kind.root().raw_id(); let node_content = std::mem::replace(node, HydroNode::Placeholder); @@ -42,14 +39,17 @@ fn add_network(node: &mut HydroNode, new_location: &LocationId) { ::hydro_lang::location::MemberId::<()>::from_raw(#ident), b )); - let cluster_id_type = quote_type::>(); - let mapped_output_type: syn::Type = syn::parse_quote!((#cluster_id_type, #output_debug_type)); + + // Calculate the new CollectionKind + let original_collection_kind = metadata.collection_kind.clone(); + let new_collection_kind = prepend_member_id_to_collection_kind(&original_collection_kind); + let mapped_node = HydroNode::Map { f: f.into(), input: Box::new(node_content), metadata: HydroIrMetadata { location_kind: metadata.location_kind.root().clone(), // Remove any ticks - output_type: Some(DebugType(Box::new(mapped_output_type.clone()))), + collection_kind: new_collection_kind.clone(), cardinality: None, tag: None, op: HydroIrOpMetadata { @@ -62,19 +62,19 @@ fn add_network(node: &mut HydroNode, new_location: &LocationId) { }; // Set up the network node - let output_type = output_debug_type.clone().0; + let output_debug_type = collection_kind_to_debug_type(&original_collection_kind); let network_node = HydroNode::Network { - serialize_fn: Some(serialize_bincode_with_type(true, &output_type)).map(|e| e.into()), + serialize_fn: Some(serialize_bincode_with_type(true, &output_debug_type)).map(|e| e.into()), instantiate_fn: DebugInstantiate::Building, deserialize_fn: Some(deserialize_bincode_with_type( Some("e_type::<()>()), - &output_type, + &output_debug_type, )) .map(|e| e.into()), input: Box::new(mapped_node), metadata: HydroIrMetadata { location_kind: new_location.clone(), - output_type: Some(DebugType(Box::new(mapped_output_type))), + collection_kind: new_collection_kind, cardinality: None, tag: None, op: HydroIrOpMetadata { @@ -93,11 +93,11 @@ fn add_network(node: &mut HydroNode, new_location: &LocationId) { input: Box::new(network_node), metadata: HydroIrMetadata { location_kind: new_location.clone(), - output_type: Some(output_debug_type), + collection_kind: original_collection_kind, cardinality: None, tag: None, op: HydroIrOpMetadata { - backtrace: metadata.op.backtrace.clone(), + backtrace: metadata.op.backtrace, cpu_usage: None, network_recv_cpu_usage: None, id: None, @@ -286,7 +286,6 @@ mod tests { use hydro_lang::compile::builder::FlowBuilder; use hydro_lang::compile::built::BuiltFlow; use hydro_lang::compile::ir; - use hydro_lang::compile::rewrites::persist_pullup::persist_pullup; use hydro_lang::location::Location; use hydro_lang::nondet::nondet; use hydro_lang::prelude::Cluster; @@ -323,7 +322,7 @@ mod tests { let multi_run_metadata = RefCell::new(vec![]); let iteration = 0; - let built = builder.optimize_with(persist_pullup).optimize_with(|ir| { + let built = builder.optimize_with(|ir| { inject_id(ir); // Convert named nodes to IDs, accounting for the offset let name_to_id = name_to_id_map(ir); diff --git a/hydro_optimize/src/deploy_and_analyze.rs b/hydro_optimize/src/deploy_and_analyze.rs index 46e14d8..5b20c19 100644 --- a/hydro_optimize/src/deploy_and_analyze.rs +++ b/hydro_optimize/src/deploy_and_analyze.rs @@ -6,7 +6,6 @@ use hydro_deploy::Deployment; use hydro_lang::compile::builder::{FlowBuilder, RewriteIrFlowBuilder}; use hydro_lang::compile::deploy::DeployResult; use hydro_lang::compile::ir::{HydroNode, HydroRoot, deep_clone, traverse_dfir}; -use hydro_lang::compile::rewrites::persist_pullup::persist_pullup; use hydro_lang::deploy::HydroDeploy; use hydro_lang::deploy::deploy_graph::DeployCrateWrapper; use hydro_lang::location::dynamic::LocationId; @@ -27,14 +26,12 @@ pub(crate) const CPU_USAGE_PREFIX: &str = "HYDRO_OPTIMIZE_CPU:"; fn insert_counter_node(node: &mut HydroNode, next_stmt_id: &mut usize, duration: syn::Expr) { match node { HydroNode::Placeholder - | HydroNode::Unpersist { .. } | HydroNode::Counter { .. } => { std::panic!("Unexpected {:?} found in insert_counter_node", node.print_root()); } HydroNode::Source { metadata, .. } | HydroNode::CycleSource { metadata, .. } | HydroNode::Persist { metadata, .. } - | HydroNode::Delta { metadata, .. } | HydroNode::Chain { metadata, .. } // Can technically be derived by summing parent cardinalities | HydroNode::ChainFirst { metadata, .. } // Can technically be derived by taking parent cardinality + 1 | HydroNode::CrossSingleton { metadata, .. } @@ -79,6 +76,13 @@ fn insert_counter_node(node: &mut HydroNode, next_stmt_id: &mut usize, duration: | HydroNode::Enumerate { .. } | HydroNode::Inspect { .. } | HydroNode::Sort { .. } + | HydroNode::Cast { .. } + | HydroNode::ObserveNonDet { .. } + | HydroNode::SingletonSource { .. } // Cardinality = 1 + | HydroNode::BeginAtomic { .. } + | HydroNode::EndAtomic { .. } + | HydroNode::Batch { .. } + | HydroNode::YieldConcat { .. } => {} } } @@ -151,7 +155,7 @@ pub async fn deploy_and_analyze<'a>( // Rewrite with counter tracking let rewritten_ir_builder = builder.rewritten_ir_builder(); - let optimized = builder.optimize_with(persist_pullup).optimize_with(|leaf| { + let optimized = builder.optimize_with(|leaf| { inject_id(leaf); insert_counter(leaf, counter_output_duration); }); diff --git a/hydro_optimize/src/partition_node_analysis.rs b/hydro_optimize/src/partition_node_analysis.rs index 1938bfa..3872a5c 100644 --- a/hydro_optimize/src/partition_node_analysis.rs +++ b/hydro_optimize/src/partition_node_analysis.rs @@ -164,8 +164,6 @@ fn input_dependency_analysis_node( HydroNode::CycleSource { .. } | HydroNode::Tee { .. } | HydroNode::Persist { .. } - | HydroNode::Unpersist { .. } - | HydroNode::Delta { .. } | HydroNode::ResolveFutures { .. } | HydroNode::ResolveFuturesOrdered { .. } | HydroNode::DeferTick { .. } @@ -176,7 +174,13 @@ fn input_dependency_analysis_node( | HydroNode::Filter { .. } // Although it contains a function f, the output is just a subset of the input, so just inherit from the parent | HydroNode::Inspect { .. } | HydroNode::Network { .. } - | HydroNode::ExternalInput { .. } => { + | HydroNode::ExternalInput { .. } + | HydroNode::Cast { .. } + | HydroNode::ObserveNonDet { .. } + | HydroNode::BeginAtomic { .. } + | HydroNode::EndAtomic { .. } + | HydroNode::Batch { .. } + | HydroNode::YieldConcat { .. } => { // For each input the first (and potentially only) parent depends on, take its dependency for input_id in input_taint_entry.iter() { if let Some(parent_dependencies_on_input) = parent_input_dependencies.get(input_id) && @@ -327,7 +331,8 @@ fn input_dependency_analysis_node( | HydroNode::Fold { .. } | HydroNode::Scan { .. } | HydroNode::FlatMap { .. } - | HydroNode::Source { .. } => { + | HydroNode::Source { .. } + | HydroNode::SingletonSource { .. } => { input_dependencies_entry.clear(); } HydroNode::Placeholder @@ -548,8 +553,6 @@ fn partitioning_constraint_analysis_node( | HydroNode::CycleSource { .. } | HydroNode::Tee { .. } | HydroNode::Persist { .. } - | HydroNode::Unpersist { .. } - | HydroNode::Delta { .. } | HydroNode::Chain { .. } | HydroNode::ChainFirst { .. } | HydroNode::ResolveFutures { .. } @@ -564,7 +567,14 @@ fn partitioning_constraint_analysis_node( | HydroNode::Sort { .. } | HydroNode::Network { .. } | HydroNode::ExternalInput { .. } - | HydroNode::Counter { .. } => { + | HydroNode::Counter { .. } + | HydroNode::Cast { .. } + | HydroNode::ObserveNonDet { .. } + | HydroNode::SingletonSource { .. } + | HydroNode::BeginAtomic { .. } + | HydroNode::EndAtomic { .. } + | HydroNode::Batch { .. } + | HydroNode::YieldConcat { .. } => { // Doesn't impede partitioning, return return; } @@ -754,7 +764,6 @@ mod tests { use std::collections::{BTreeMap, BTreeSet, HashMap}; use hydro_lang::compile::ir::deep_clone; - use hydro_lang::compile::rewrites::persist_pullup::persist_pullup; use hydro_lang::deploy::HydroDeploy; use hydro_lang::live_collections::stream::NoOrder; use hydro_lang::location::dynamic::LocationId; @@ -779,7 +788,6 @@ mod tests { ) { let mut cycle_data = HashMap::new(); let built = builder - .optimize_with(persist_pullup) .optimize_with(|ir| { inject_id(ir); cycle_data = cycle_source_to_sink_input(ir); @@ -880,7 +888,6 @@ mod tests { ) { let mut cycle_data = HashMap::new(); let built = builder - .optimize_with(persist_pullup) .optimize_with(|ir| { inject_id(ir); cycle_data = cycle_source_to_sink_input(ir); diff --git a/hydro_optimize/src/partitioner.rs b/hydro_optimize/src/partitioner.rs index 4c427ae..c22bd44 100644 --- a/hydro_optimize/src/partitioner.rs +++ b/hydro_optimize/src/partitioner.rs @@ -1,15 +1,14 @@ use core::panic; use std::collections::HashMap; -use hydro_lang::compile::ir::{BoundKind, CollectionKind, DebugType, HydroNode, HydroRoot, KeyedSingletonBoundKind, StreamOrder, StreamRetry, traverse_dfir}; -use hydro_lang::live_collections::keyed_singleton::KeyedSingletonBound; +use hydro_lang::compile::ir::{HydroNode, HydroRoot, traverse_dfir}; use hydro_lang::location::dynamic::LocationId; use serde::{Deserialize, Serialize}; use syn::visit_mut::{self, VisitMut}; use crate::partition_syn_analysis::StructOrTupleIndex; use crate::repair::inject_id; -use crate::rewrites::{ClusterSelfIdReplace, NetworkType, collection_kind_to_debug_type, deserialize_bincode_with_type, get_network_type, serialize_bincode_with_type}; +use crate::rewrites::{ClusterSelfIdReplace, NetworkType, collection_kind_to_debug_type, deserialize_bincode_with_type, get_network_type, prepend_member_id_to_collection_kind, serialize_bincode_with_type}; #[derive(Clone, Serialize, Deserialize)] pub struct Partitioner { @@ -126,29 +125,7 @@ fn replace_sender_dest(node: &mut HydroNode, partitioner: &Partitioner, next_stm let f: syn::Expr = if new_cluster_id.is_some() { // Output type of Map now includes dest ID - let member_id_syn_type: syn::Type = syn::parse_quote! { ::hydro_lang::location::MemberId<()> }; - let member_id_debug_type = DebugType::from(member_id_syn_type); - metadata.collection_kind = match metadata.collection_kind { - CollectionKind::Singleton { element_type, .. } - | CollectionKind::Optional { element_type, .. } => { - CollectionKind::KeyedSingleton { - bound: KeyedSingletonBoundKind::Unbounded, - key_type: member_id_debug_type, - value_type: element_type, - } - } - CollectionKind::Stream { .. } - | CollectionKind::KeyedStream { .. } - | CollectionKind::KeyedSingleton { .. } => { - CollectionKind::KeyedStream { - bound: BoundKind::Unbounded, - value_order: StreamOrder::NoOrder, - value_retry: StreamRetry::ExactlyOnce, - key_type: member_id_debug_type, - value_type: collection_kind_to_debug_type(&metadata.collection_kind), - } - } - }; + metadata.collection_kind = prepend_member_id_to_collection_kind(&metadata.collection_kind); // Partitioning a process into a cluster syn::parse_quote!( diff --git a/hydro_optimize/src/rewrites.rs b/hydro_optimize/src/rewrites.rs index a53c86b..1b9f118 100644 --- a/hydro_optimize/src/rewrites.rs +++ b/hydro_optimize/src/rewrites.rs @@ -2,7 +2,7 @@ use std::cell::RefCell; use std::collections::HashMap; use hydro_lang::compile::builder::{FlowBuilder, RewriteIrFlowBuilder}; -use hydro_lang::compile::ir::{CollectionKind, DebugType, HydroIrMetadata, HydroNode, HydroRoot, deep_clone, traverse_dfir}; +use hydro_lang::compile::ir::{BoundKind, CollectionKind, DebugType, HydroIrMetadata, HydroNode, HydroRoot, KeyedSingletonBoundKind, StreamOrder, StreamRetry, deep_clone, traverse_dfir}; use hydro_lang::location::dynamic::LocationId; use hydro_lang::location::{Cluster, Location}; use serde::{Deserialize, Serialize}; @@ -272,4 +272,30 @@ pub fn collection_kind_to_debug_type(collection_kind: &CollectionKind) -> DebugT DebugType::from(new_type) } } -} \ No newline at end of file +} + +pub fn prepend_member_id_to_collection_kind(collection_kind: &CollectionKind) -> CollectionKind { + let member_id_syn_type: syn::Type = syn::parse_quote! { ::hydro_lang::location::MemberId<()> }; + let member_id_debug_type = DebugType::from(member_id_syn_type); + match collection_kind { + CollectionKind::Singleton { element_type, .. } + | CollectionKind::Optional { element_type, .. } => { + CollectionKind::KeyedSingleton { + bound: KeyedSingletonBoundKind::Unbounded, + key_type: member_id_debug_type, + value_type: element_type.clone(), + } + } + CollectionKind::Stream { .. } + | CollectionKind::KeyedStream { .. } + | CollectionKind::KeyedSingleton { .. } => { + CollectionKind::KeyedStream { + bound: BoundKind::Unbounded, + value_order: StreamOrder::NoOrder, + value_retry: StreamRetry::ExactlyOnce, + key_type: member_id_debug_type, + value_type: collection_kind_to_debug_type(&collection_kind), + } + } + } +} diff --git a/hydro_optimize_examples/examples/benchmark_paxos.rs b/hydro_optimize_examples/examples/benchmark_paxos.rs index e56ec6c..7a20dd8 100644 --- a/hydro_optimize_examples/examples/benchmark_paxos.rs +++ b/hydro_optimize_examples/examples/benchmark_paxos.rs @@ -19,7 +19,7 @@ async fn main() { #[command(author, version, about, long_about = None)] struct BenchmarkArgs { #[command(flatten)] - graph: hydro_lang::graph::config::GraphConfig, + graph: hydro_lang::viz::config::GraphConfig, /// Use GCP for deployment (provide project name) #[arg(long)] diff --git a/hydro_optimize_examples/examples/decouple_compute_pi.rs b/hydro_optimize_examples/examples/decouple_compute_pi.rs index 8727243..b3ac6c9 100644 --- a/hydro_optimize_examples/examples/decouple_compute_pi.rs +++ b/hydro_optimize_examples/examples/decouple_compute_pi.rs @@ -15,9 +15,8 @@ struct Args { } use hydro_deploy::gcp::GcpNetwork; use hydro_deploy::{Deployment, Host}; -use hydro_lang::compile::rewrites::persist_pullup; use hydro_lang::deploy::TrybuildHost; -use hydro_lang::graph::config::GraphConfig; +use hydro_lang::viz::config::GraphConfig; use hydro_lang::location::Location; use hydro_optimize::debug; use hydro_optimize::decoupler::{self, Decoupler}; @@ -82,7 +81,6 @@ async fn main() { let multi_run_metadata = RefCell::new(vec![]); let _nodes = built - .optimize_with(persist_pullup::persist_pullup) .optimize_with(|roots| decoupler::decouple(roots, &decoupler, &multi_run_metadata, 0)) .optimize_with(debug::print_id) .with_process( diff --git a/hydro_optimize_examples/examples/partition_simple_cluster.rs b/hydro_optimize_examples/examples/partition_simple_cluster.rs index 6b2e790..51c43b5 100644 --- a/hydro_optimize_examples/examples/partition_simple_cluster.rs +++ b/hydro_optimize_examples/examples/partition_simple_cluster.rs @@ -15,9 +15,8 @@ struct Args { } use hydro_deploy::gcp::GcpNetwork; use hydro_deploy::{Deployment, Host}; -use hydro_lang::compile::rewrites::persist_pullup; use hydro_lang::deploy::TrybuildHost; -use hydro_lang::graph::config::GraphConfig; +use hydro_lang::viz::config::GraphConfig; use hydro_lang::location::Location; use hydro_optimize::partitioner::{self, Partitioner}; use tokio::sync::RwLock; @@ -73,7 +72,6 @@ async fn main() { let _ = built.generate_graph_with_config(&args.graph, None); let _nodes = built - .optimize_with(persist_pullup::persist_pullup) .optimize_with(|roots| partitioner::partition(roots, &partitioner)) .with_process( &process, diff --git a/hydro_optimize_examples/examples/partition_two_pc.rs b/hydro_optimize_examples/examples/partition_two_pc.rs index b3e9f05..35ee680 100644 --- a/hydro_optimize_examples/examples/partition_two_pc.rs +++ b/hydro_optimize_examples/examples/partition_two_pc.rs @@ -3,7 +3,6 @@ use std::sync::Arc; use hydro_deploy::gcp::GcpNetwork; use hydro_deploy::{Deployment, Host}; -use hydro_lang::compile::rewrites::persist_pullup::persist_pullup; use hydro_lang::deploy::TrybuildHost; use hydro_lang::location::Location; use hydro_optimize::partition_node_analysis::{nodes_to_partition, partitioning_analysis}; @@ -60,7 +59,6 @@ async fn main() { let mut cycle_data = HashMap::new(); let deployable = builder - .optimize_with(persist_pullup) .optimize_with(|ir| { inject_id(ir); cycle_data = cycle_source_to_sink_input(ir); diff --git a/hydro_optimize_examples/examples/perf_compute_pi.rs b/hydro_optimize_examples/examples/perf_compute_pi.rs index 2dcde56..4d027c4 100644 --- a/hydro_optimize_examples/examples/perf_compute_pi.rs +++ b/hydro_optimize_examples/examples/perf_compute_pi.rs @@ -17,7 +17,7 @@ async fn main() { use clap::Parser; use hydro_deploy::Deployment; use hydro_deploy::gcp::GcpNetwork; - use hydro_lang::graph::config::GraphConfig; + use hydro_lang::viz::config::GraphConfig; use hydro_lang::location::Location; use hydro_optimize::deploy::ReusableHosts; use hydro_optimize::deploy_and_analyze::deploy_and_analyze; diff --git a/hydro_optimize_examples/examples/perf_paxos.rs b/hydro_optimize_examples/examples/perf_paxos.rs index 991d05d..84bd94a 100644 --- a/hydro_optimize_examples/examples/perf_paxos.rs +++ b/hydro_optimize_examples/examples/perf_paxos.rs @@ -8,7 +8,7 @@ async fn main() { use clap::Parser; use hydro_deploy::Deployment; use hydro_deploy::gcp::GcpNetwork; - use hydro_lang::graph::config::GraphConfig; + use hydro_lang::viz::config::GraphConfig; use hydro_lang::location::Location; use hydro_optimize::decoupler; use hydro_optimize::deploy::ReusableHosts; diff --git a/hydro_optimize_examples/examples/simple_graphs.rs b/hydro_optimize_examples/examples/simple_graphs.rs index eb62392..6182d24 100644 --- a/hydro_optimize_examples/examples/simple_graphs.rs +++ b/hydro_optimize_examples/examples/simple_graphs.rs @@ -5,7 +5,7 @@ use std::sync::Arc; use clap::Parser; use hydro_deploy::Deployment; use hydro_deploy::gcp::GcpNetwork; -use hydro_lang::graph::config::GraphConfig; +use hydro_lang::viz::config::GraphConfig; use hydro_lang::location::Location; use hydro_lang::prelude::FlowBuilder; use hydro_optimize::decoupler; From 9a87932c7d032ea7c60076df61573862dadf879d Mon Sep 17 00:00:00 2001 From: David Chu Date: Tue, 28 Oct 2025 21:22:24 +0000 Subject: [PATCH 07/35] HydroRoot input() and input_metadata() no longer return vecs --- hydro_optimize/src/debug.rs | 8 ++------ hydro_optimize/src/decouple_analysis.rs | 4 ++-- hydro_optimize/src/decoupler.rs | 2 +- hydro_optimize/src/parse_results.rs | 4 ++-- hydro_optimize/src/rewrites.rs | 2 +- hydro_optimize_examples/src/simple_graphs.rs | 16 ++++++++++++++++ 6 files changed, 24 insertions(+), 12 deletions(-) diff --git a/hydro_optimize/src/debug.rs b/hydro_optimize/src/debug.rs index faa11cf..b8e49c2 100644 --- a/hydro_optimize/src/debug.rs +++ b/hydro_optimize/src/debug.rs @@ -3,16 +3,12 @@ use std::collections::HashMap; use hydro_lang::compile::ir::{HydroNode, HydroRoot, traverse_dfir}; fn print_id_root(root: &mut HydroRoot, next_stmt_id: &mut usize) { - let inputs = root - .input_metadata() - .iter() - .map(|m| m.op.id) - .collect::>>(); + let input = root.input_metadata().op.id; println!( "{} Root {}, Inputs: {:?}", next_stmt_id, root.print_root(), - inputs, + input, ); } diff --git a/hydro_optimize/src/decouple_analysis.rs b/hydro_optimize/src/decouple_analysis.rs index 258b30b..813ff9d 100644 --- a/hydro_optimize/src/decouple_analysis.rs +++ b/hydro_optimize/src/decouple_analysis.rs @@ -290,12 +290,12 @@ fn decouple_analysis_root( model_metadata: &RefCell, ) { // Ignore nodes that are not in the cluster to decouple - if model_metadata.borrow().cluster_to_decouple != *root.input_metadata()[0].location_kind.root() + if model_metadata.borrow().cluster_to_decouple != *root.input_metadata().location_kind.root() { return; } - add_tick_constraint(root.input_metadata()[0], op_id_to_inputs, model_metadata); + add_tick_constraint(root.input_metadata(), op_id_to_inputs, model_metadata); } fn decouple_analysis_node( diff --git a/hydro_optimize/src/decoupler.rs b/hydro_optimize/src/decoupler.rs index 7af2e3f..3daa6cc 100644 --- a/hydro_optimize/src/decoupler.rs +++ b/hydro_optimize/src/decoupler.rs @@ -215,7 +215,7 @@ fn fix_cluster_self_id_root(root: &mut HydroRoot, mut locations: ClusterSelfIdRe decoupled_cluster_id, .. } = locations - && root.input_metadata()[0].location_kind.root().raw_id() == decoupled_cluster_id + && root.input_metadata().location_kind.root().raw_id() == decoupled_cluster_id { root.visit_debug_expr(|expr| { locations.visit_expr_mut(&mut expr.0); diff --git a/hydro_optimize/src/parse_results.rs b/hydro_optimize/src/parse_results.rs index 741f3ce..59a03d2 100644 --- a/hydro_optimize/src/parse_results.rs +++ b/hydro_optimize/src/parse_results.rs @@ -367,11 +367,11 @@ fn record_metadata( } fn record_metadata_root(root: &mut HydroRoot, run_metadata: &mut RunMetadata) { - record_metadata(root.op_metadata(), root.input_metadata(), run_metadata); + record_metadata(root.op_metadata(), vec![root.input_metadata()], run_metadata); // Location = input's location, cardinality = input's cardinality let id = root.op_metadata().id.unwrap(); - let input = root.input_metadata()[0]; + let input = root.input_metadata(); run_metadata .op_id_to_location .insert(id, input.location_kind.root().clone()); diff --git a/hydro_optimize/src/rewrites.rs b/hydro_optimize/src/rewrites.rs index 1b9f118..6ba7552 100644 --- a/hydro_optimize/src/rewrites.rs +++ b/hydro_optimize/src/rewrites.rs @@ -151,7 +151,7 @@ pub fn op_id_to_inputs( traverse_dfir( ir, |leaf, op_id| { - let relevant_input_ids = relevant_inputs(leaf.input_metadata(), location); + let relevant_input_ids = relevant_inputs(vec![leaf.input_metadata()], location); mapping.borrow_mut().insert(*op_id, relevant_input_ids); }, |node, op_id| { diff --git a/hydro_optimize_examples/src/simple_graphs.rs b/hydro_optimize_examples/src/simple_graphs.rs index 08fbb98..437e53d 100644 --- a/hydro_optimize_examples/src/simple_graphs.rs +++ b/hydro_optimize_examples/src/simple_graphs.rs @@ -49,6 +49,7 @@ fn sha256(n: u32) -> u32 { pub fn get_graph_function<'a>(name: &str) -> impl GraphFunction<'a> { match name { "noop" => noop, + "map_h_map_h" => map_h_map_h, "map_h_map_h_map_h" => map_h_map_h_map_h, "map_h_map_h_map_l" => map_h_map_h_map_l, "map_h_map_l_map_h" => map_h_map_l_map_h, @@ -92,6 +93,21 @@ pub fn noop<'a>( payloads } +pub fn map_h_map_h<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + payloads + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(100 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(100 + n % 2) + ))) +} + pub fn map_h_map_h_map_h<'a>( _server: &Cluster<'a, Server>, payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, From 8e068e72387948249385d7ec566789f0fa85e13e Mon Sep 17 00:00:00 2001 From: David Chu Date: Mon, 3 Nov 2025 22:37:25 +0000 Subject: [PATCH 08/35] Started network_calibrator, untested --- .gitignore | 6 +- hydro_optimize/src/deploy.rs | 7 +- .../examples/network_calibrator.rs | 112 ++++++++++++++++++ hydro_optimize_examples/src/lib.rs | 1 + .../src/network_calibrator.rs | 50 ++++++++ 5 files changed, 169 insertions(+), 7 deletions(-) create mode 100644 hydro_optimize_examples/examples/network_calibrator.rs create mode 100644 hydro_optimize_examples/src/network_calibrator.rs diff --git a/.gitignore b/.gitignore index 98d6e30..e13ee29 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,7 @@ target/ *.data.folded -*.perf.data \ No newline at end of file +*.perf.data +scripts/*.png + +# I'll output the results of cargo run to these files +*.results.txt \ No newline at end of file diff --git a/hydro_optimize/src/deploy.rs b/hydro_optimize/src/deploy.rs index 4c84252..f7494ab 100644 --- a/hydro_optimize/src/deploy.rs +++ b/hydro_optimize/src/deploy.rs @@ -46,18 +46,13 @@ impl ReusableHosts { deployment: &mut Deployment, display_name: String, ) -> TrybuildHost { - let rustflags = if self.host_arg == "gcp" { - "-C opt-level=3 -C codegen-units=1 -C strip=none -C debuginfo=2 -C lto=off -C link-args=--no-rosegment" - } else { - "-C opt-level=3 -C codegen-units=1 -C strip=none -C debuginfo=2 -C lto=off" - }; TrybuildHost::new(self.lazy_create_host(deployment, display_name.clone())) .additional_hydro_features(vec!["runtime_measure".to_string()]) .build_env( "HYDRO_RUNTIME_MEASURE_CPU_PREFIX", super::deploy_and_analyze::CPU_USAGE_PREFIX, ) - .rustflags(rustflags) + .rustflags("-C opt-level=3 -C codegen-units=1 -C strip=none -C debuginfo=2 -C lto=off") .tracing( TracingOptions::builder() .perf_raw_outfile(format!("{}.perf.data", display_name.clone())) diff --git a/hydro_optimize_examples/examples/network_calibrator.rs b/hydro_optimize_examples/examples/network_calibrator.rs new file mode 100644 index 0000000..6658f8a --- /dev/null +++ b/hydro_optimize_examples/examples/network_calibrator.rs @@ -0,0 +1,112 @@ +use std::cell::RefCell; +use std::collections::HashMap; +use std::sync::Arc; + +use clap::Parser; +use hydro_deploy::Deployment; +use hydro_deploy::gcp::GcpNetwork; +use hydro_lang::viz::config::GraphConfig; +use hydro_lang::location::Location; +use hydro_lang::prelude::FlowBuilder; +use hydro_optimize::deploy::ReusableHosts; +use hydro_optimize::deploy_and_analyze::deploy_and_analyze; +use hydro_optimize_examples::network_calibrator::{Aggregator, Client, Server, network_calibrator}; +use tokio::sync::RwLock; + +#[derive(Parser, Debug)] +#[command(author, version, about, long_about = None)] +struct Args { + #[command(flatten)] + graph: GraphConfig, + + /// Use GCP for deployment (provide project name) + #[arg(long)] + gcp: Option, + + #[arg(long)] + function: String, +} + +#[tokio::main] +async fn main() { + let args = Args::parse(); + + let mut deployment = Deployment::new(); + let (host_arg, project) = if let Some(project) = args.gcp { + ("gcp".to_string(), project) + } else { + ("localhost".to_string(), String::new()) + }; + let network = Arc::new(RwLock::new(GcpNetwork::new(&project, None))); + + let mut builder = FlowBuilder::new(); + let num_clients = 1; + let num_clients_per_node = 10000000; + let server = builder.cluster(); + let clients = builder.cluster(); + let client_aggregator = builder.process(); + + let clusters = vec![ + ( + server.id().raw_id(), + std::any::type_name::().to_string(), + 1, + ), + ( + clients.id().raw_id(), + std::any::type_name::().to_string(), + num_clients, + ), + ]; + let processes = vec![( + client_aggregator.id().raw_id(), + std::any::type_name::().to_string(), + )]; + + // Deploy + let mut reusable_hosts = ReusableHosts { + hosts: HashMap::new(), + host_arg, + project: project.clone(), + network: network.clone(), + }; + + let message_sizes = vec![1, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192]; + let num_seconds_to_profile = Some(20); + let multi_run_metadata = RefCell::new(vec![]); + + for (i, message_size) in message_sizes.iter().enumerate() { + + network_calibrator( + num_clients_per_node, + *message_size, + &server, + &clients, + &client_aggregator, + ); + + let (rewritten_ir_builder, ir, _, _, _) = + deploy_and_analyze( + &mut reusable_hosts, + &mut deployment, + builder, + &clusters, + &processes, + vec![ + std::any::type_name::().to_string(), + std::any::type_name::().to_string(), + ], + num_seconds_to_profile, + &multi_run_metadata, + i, + ) + .await; + + builder = rewritten_ir_builder.build_with(|_| ir); + } + + let built = builder.finalize(); + + // Generate graphs if requested + _ = built.generate_graph_with_config(&args.graph, None); +} \ No newline at end of file diff --git a/hydro_optimize_examples/src/lib.rs b/hydro_optimize_examples/src/lib.rs index 9617274..aebaec4 100644 --- a/hydro_optimize_examples/src/lib.rs +++ b/hydro_optimize_examples/src/lib.rs @@ -1,5 +1,6 @@ stageleft::stageleft_no_entry_crate!(); +pub mod network_calibrator; pub mod simple_graphs; pub mod simple_graphs_bench; pub mod simple_kv_bench; diff --git a/hydro_optimize_examples/src/network_calibrator.rs b/hydro_optimize_examples/src/network_calibrator.rs new file mode 100644 index 0000000..8b2a3d1 --- /dev/null +++ b/hydro_optimize_examples/src/network_calibrator.rs @@ -0,0 +1,50 @@ +use hydro_lang::{live_collections::stream::NoOrder, nondet::nondet, prelude::{Cluster, Process, Stream, Unbounded}}; +use hydro_std::bench_client::{bench_client, print_bench_results}; + +use stageleft::q; + +pub struct Client; +pub struct Server; +pub struct Aggregator; + +pub fn network_calibrator<'a>( + num_clients_per_node: usize, + message_size: usize, + server: &Cluster<'a, Server>, + clients: &Cluster<'a, Client>, + client_aggregator: &Process<'a, Aggregator>, +) { + let bench_results = bench_client( + clients, + |_client, payload_request| { + size_based_workload_generator(message_size, payload_request) + }, + |payloads| { + // Server just echoes the payload + payloads + .broadcast_bincode(server, nondet!(/** Test */)) + .demux_bincode(clients) + .values() + }, + num_clients_per_node, + nondet!(/** bench */), + ); + + print_bench_results(bench_results, client_aggregator, clients); +} + +/// Generates an incrementing u32 for each virtual client ID, starting at 0 +pub fn size_based_workload_generator<'a, Client>( + message_size: usize, + payload_request: Stream<(u32, Option>), Cluster<'a, Client>, Unbounded, NoOrder>, +) -> Stream<(u32, Vec), Cluster<'a, Client>, Unbounded, NoOrder> { + payload_request.map(q!(move |(virtual_id, payload)| { + if let Some(mut payload) = payload { + if let Some(last) = payload.last_mut() { + *last += 1; + return (virtual_id, payload); + } + } + (virtual_id, vec![0; message_size]) + })) +} \ No newline at end of file From b5bcb65285b95db9f7da3513cade809bc3884e22 Mon Sep 17 00:00:00 2001 From: David Chu Date: Mon, 3 Nov 2025 23:19:48 +0000 Subject: [PATCH 09/35] Map tests without decouple penalty --- .../examples/simple_graphs.rs | 8 +- hydro_optimize_examples/src/simple_graphs.rs | 126 ++++++++++++++++++ .../src/simple_graphs_bench.rs | 39 +++++- 3 files changed, 171 insertions(+), 2 deletions(-) diff --git a/hydro_optimize_examples/examples/simple_graphs.rs b/hydro_optimize_examples/examples/simple_graphs.rs index 6182d24..48570ca 100644 --- a/hydro_optimize_examples/examples/simple_graphs.rs +++ b/hydro_optimize_examples/examples/simple_graphs.rs @@ -12,7 +12,7 @@ use hydro_optimize::decoupler; use hydro_optimize::deploy::ReusableHosts; use hydro_optimize::deploy_and_analyze::deploy_and_analyze; use hydro_optimize_examples::simple_graphs::{Client, Server, get_graph_function}; -use hydro_optimize_examples::simple_graphs_bench::{Aggregator, simple_graphs_bench}; +use hydro_optimize_examples::simple_graphs_bench::{Aggregator, simple_graphs_bench, simple_graphs_bench_no_union}; use tokio::sync::RwLock; #[derive(Parser, Debug)] @@ -56,6 +56,12 @@ async fn main() { &client_aggregator, graph_function, ); + // simple_graphs_bench_no_union( + // num_clients_per_node, + // &server, + // &clients, + // &client_aggregator, + // ); let mut clusters = vec![ ( diff --git a/hydro_optimize_examples/src/simple_graphs.rs b/hydro_optimize_examples/src/simple_graphs.rs index 437e53d..dba95be 100644 --- a/hydro_optimize_examples/src/simple_graphs.rs +++ b/hydro_optimize_examples/src/simple_graphs.rs @@ -50,6 +50,8 @@ pub fn get_graph_function<'a>(name: &str) -> impl GraphFunction<'a> { match name { "noop" => noop, "map_h_map_h" => map_h_map_h, + "map_h_map_h_split_up" => map_h_map_h_split_up, + "map_h_map_h_parallel" => map_h_map_h_parallel, "map_h_map_h_map_h" => map_h_map_h_map_h, "map_h_map_h_map_l" => map_h_map_h_map_l, "map_h_map_l_map_h" => map_h_map_l_map_h, @@ -108,6 +110,130 @@ pub fn map_h_map_h<'a>( ))) } +pub fn map_h_map_h_split_up<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + payloads + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(10 + n % 2) + ))) +} + +pub fn map_h_map_h_parallel<'a>( + _server: &Cluster<'a, Server>, + payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { + let batch0 = payloads.clone().filter(q!(|(virt_client_id, _)| virt_client_id % 2 == 0)); + let batch1 = payloads.filter(q!(|(virt_client_id, _)| virt_client_id % 2 == 1)); + let batch0out = batch0 + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(100 + n % 2) + ))); + batch1 + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(100 + n % 2) + ))) + .interleave(batch0out) +} + +pub fn map_h_map_h_parallel_no_union<'a>( + _server: &Cluster<'a, Server>, + payloads1: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, + payloads2: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +) -> (KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, +KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>) { + (payloads1 + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(100 + n % 2) + ))), + payloads2 + .map(q!(|(virt_client_id, n)| ( + virt_client_id, + self::sha256(100 + n % 2) + )))) +} + pub fn map_h_map_h_map_h<'a>( _server: &Cluster<'a, Server>, payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, diff --git a/hydro_optimize_examples/src/simple_graphs_bench.rs b/hydro_optimize_examples/src/simple_graphs_bench.rs index 84bb2e8..57ae990 100644 --- a/hydro_optimize_examples/src/simple_graphs_bench.rs +++ b/hydro_optimize_examples/src/simple_graphs_bench.rs @@ -2,7 +2,8 @@ use hydro_lang::{prelude::{Cluster, Process}, nondet::nondet}; use hydro_std::bench_client::{bench_client, print_bench_results}; use hydro_test::cluster::paxos_bench::inc_u32_workload_generator; -use crate::simple_graphs::{Client, GraphFunction, Server}; +use stageleft::q; +use crate::simple_graphs::{Client, GraphFunction, Server, map_h_map_h_parallel_no_union}; pub struct Aggregator; pub fn simple_graphs_bench<'a>( @@ -29,5 +30,41 @@ pub fn simple_graphs_bench<'a>( nondet!(/** bench */), ); + print_bench_results(bench_results, client_aggregator, clients); +} + +pub fn simple_graphs_bench_no_union<'a>( + num_clients_per_node: usize, + server: &Cluster<'a, Server>, + clients: &Cluster<'a, Client>, + client_aggregator: &Process<'a, Aggregator>, +) { + let bench_results = bench_client( + clients, + inc_u32_workload_generator, + |payloads| { + let payloads1 = payloads.clone().filter(q!(|(virt_client_id, _)| virt_client_id % 2 == 0)); + let payloads2 = payloads.filter(q!(|(virt_client_id, _)| virt_client_id % 2 == 1)); + let (batch0, batch1) = map_h_map_h_parallel_no_union( + server, + payloads1 + .broadcast_bincode(server, nondet!(/** Test */)) + .into(), + payloads2 + .broadcast_bincode(server, nondet!(/** Test */)) + .into(), + ); + let clients_batch0 = batch0 + .demux_bincode(clients) + .values(); + batch1 + .demux_bincode(clients) + .values() + .interleave(clients_batch0) + }, + num_clients_per_node, + nondet!(/** bench */), + ); + print_bench_results(bench_results, client_aggregator, clients); } \ No newline at end of file From 760b4666e34e2d9f545bbe4fa35f62e7f10be077 Mon Sep 17 00:00:00 2001 From: David Chu Date: Wed, 5 Nov 2025 18:03:20 +0000 Subject: [PATCH 10/35] Fix Cargo.lock --- Cargo.lock | 40 ++++------------------------------------ 1 file changed, 4 insertions(+), 36 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 56aa0a9..fee4098 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -106,12 +106,6 @@ version = "0.2.21" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" -[[package]] -name = "allocator-api2" -version = "0.2.21" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" - [[package]] name = "android_system_properties" version = "0.1.5" @@ -1669,10 +1663,6 @@ dependencies = [ "ahash", "allocator-api2", ] -dependencies = [ - "ahash", - "allocator-api2", -] [[package]] name = "hashbrown" @@ -1859,7 +1849,6 @@ dependencies = [ "pin-project-lite", "serde", "sinktools", - "sinktools", "tempfile", "tokio", "tokio-stream", @@ -1879,7 +1868,6 @@ dependencies = [ "data-encoding", "dfir_lang", "flate2", - "flate2", "futures", "hydro_build_utils", "hydro_deploy", @@ -1904,7 +1892,6 @@ dependencies = [ "toml", "trybuild-internals-api", "urlencoding", - "urlencoding", "webbrowser", ] @@ -1922,10 +1909,8 @@ dependencies = [ "hydro_test", "include_mdtests", "proc-macro-crate", - "proc-macro-crate", "proc-macro2", "quote", - "quote", "regex", "serde", "stageleft", @@ -1941,8 +1926,6 @@ dependencies = [ "ctor 0.2.9", "dfir_lang", "hydro_build_utils", - "dfir_lang", - "hydro_build_utils", "hydro_deploy", "hydro_lang", "hydro_optimize", @@ -1951,9 +1934,6 @@ dependencies = [ "regex", "serde", "sha2", - "regex", - "serde", - "sha2", "stageleft", "stageleft_tool", "tokio", @@ -2298,9 +2278,9 @@ checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130" [[package]] name = "iri-string" -version = "0.7.8" +version = "0.7.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dbc5ebe9c3a1a7a5127f920a418f7585e9e758e911d0466ed004f393b0e380b2" +checksum = "4f867b9d1d896b67beb18518eda36fdb77a32ea590de864f1325b294a6d14397" dependencies = [ "memchr", "serde", @@ -3717,9 +3697,9 @@ dependencies = [ [[package]] name = "rustls" -version = "0.23.34" +version = "0.23.35" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6a9586e9ee2b4f8fab52a0048ca7334d7024eef48e2cb9407e3497bb7cab7fa7" +checksum = "533f54bc6a7d4f647e46ad909549eda97bf5afc1585190ef692b4286b198bd8f" dependencies = [ "once_cell", "ring", @@ -4145,10 +4125,8 @@ checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" [[package]] name = "stageleft" version = "0.10.0" -version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b92cb4d28ec3c2b3aba8ee05487f10c3aa00d7a369a3fe9d4d89e8719f28ca4f" -checksum = "b92cb4d28ec3c2b3aba8ee05487f10c3aa00d7a369a3fe9d4d89e8719f28ca4f" dependencies = [ "ctor 0.4.3", "proc-macro-crate", @@ -4161,10 +4139,8 @@ dependencies = [ [[package]] name = "stageleft_macro" version = "0.10.0" -version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e05624677c37d2abebe0c3e50fa7722f99936d26de2a8a23ac5d2a397be596c0" -checksum = "e05624677c37d2abebe0c3e50fa7722f99936d26de2a8a23ac5d2a397be596c0" dependencies = [ "proc-macro-crate", "proc-macro2", @@ -4176,10 +4152,8 @@ dependencies = [ [[package]] name = "stageleft_tool" version = "0.10.0" -version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "da14207006ed0031a24197e0a2d3bc84b2a7ecf3a2ca70b70f1886cf1a37b464" -checksum = "da14207006ed0031a24197e0a2d3bc84b2a7ecf3a2ca70b70f1886cf1a37b464" dependencies = [ "prettyplease", "proc-macro-crate", @@ -4738,12 +4712,6 @@ version = "2.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da" -[[package]] -name = "urlencoding" -version = "2.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da" - [[package]] name = "utf8_iter" version = "1.0.4" From c98987f6a1fd281019466474851832aed518cdf0 Mon Sep 17 00:00:00 2001 From: David Chu Date: Fri, 7 Nov 2025 00:49:09 +0000 Subject: [PATCH 11/35] Network calibrator running --- .../examples/network_calibrator.rs | 68 +++++++++---------- .../src/network_calibrator.rs | 5 +- 2 files changed, 36 insertions(+), 37 deletions(-) diff --git a/hydro_optimize_examples/examples/network_calibrator.rs b/hydro_optimize_examples/examples/network_calibrator.rs index 6658f8a..5688ad4 100644 --- a/hydro_optimize_examples/examples/network_calibrator.rs +++ b/hydro_optimize_examples/examples/network_calibrator.rs @@ -22,9 +22,6 @@ struct Args { /// Use GCP for deployment (provide project name) #[arg(long)] gcp: Option, - - #[arg(long)] - function: String, } #[tokio::main] @@ -39,29 +36,8 @@ async fn main() { }; let network = Arc::new(RwLock::new(GcpNetwork::new(&project, None))); - let mut builder = FlowBuilder::new(); - let num_clients = 1; - let num_clients_per_node = 10000000; - let server = builder.cluster(); - let clients = builder.cluster(); - let client_aggregator = builder.process(); - - let clusters = vec![ - ( - server.id().raw_id(), - std::any::type_name::().to_string(), - 1, - ), - ( - clients.id().raw_id(), - std::any::type_name::().to_string(), - num_clients, - ), - ]; - let processes = vec![( - client_aggregator.id().raw_id(), - std::any::type_name::().to_string(), - )]; + let num_clients = 5; // >1 clients so it doesn't become the bottleneck + let num_clients_per_node = 1; // Deploy let mut reusable_hosts = ReusableHosts { @@ -75,11 +51,33 @@ async fn main() { let num_seconds_to_profile = Some(20); let multi_run_metadata = RefCell::new(vec![]); - for (i, message_size) in message_sizes.iter().enumerate() { - + for message_size in message_sizes { + let builder = FlowBuilder::new(); + let server = builder.cluster(); + let clients = builder.cluster(); + let client_aggregator = builder.process(); + + let clusters = vec![ + ( + server.id().raw_id(), + std::any::type_name::().to_string(), + 1, + ), + ( + clients.id().raw_id(), + std::any::type_name::().to_string(), + num_clients, + ), + ]; + let processes = vec![( + client_aggregator.id().raw_id(), + std::any::type_name::().to_string(), + )]; + + println!("Running network calibrator with message size: {} bytes, num clients: {}", message_size, num_clients); network_calibrator( num_clients_per_node, - *message_size, + message_size, &server, &clients, &client_aggregator, @@ -98,15 +96,13 @@ async fn main() { ], num_seconds_to_profile, &multi_run_metadata, - i, + 0, // Set to 0 to turn off comparisons between iterations ) .await; - builder = rewritten_ir_builder.build_with(|_| ir); - } - - let built = builder.finalize(); + let built = rewritten_ir_builder.build_with(|_| ir).finalize(); - // Generate graphs if requested - _ = built.generate_graph_with_config(&args.graph, None); + // Generate graphs if requested + _ = built.generate_graph_with_config(&args.graph, None); + } } \ No newline at end of file diff --git a/hydro_optimize_examples/src/network_calibrator.rs b/hydro_optimize_examples/src/network_calibrator.rs index 8b2a3d1..fc2f058 100644 --- a/hydro_optimize_examples/src/network_calibrator.rs +++ b/hydro_optimize_examples/src/network_calibrator.rs @@ -45,6 +45,9 @@ pub fn size_based_workload_generator<'a, Client>( return (virtual_id, payload); } } - (virtual_id, vec![0; message_size]) + + // Temp fix for macro stuff that isn't supported by stageleft I guess + let msg_size = message_size; + (virtual_id, vec![0; msg_size]) })) } \ No newline at end of file From 02ba6e9b66a698b0a4b4e218015fea9e9b4fbe54 Mon Sep 17 00:00:00 2001 From: David Chu Date: Mon, 10 Nov 2025 18:54:29 +0000 Subject: [PATCH 12/35] Saturate network calibrator --- Cargo.lock | 21 +++++++++++++------ .../examples/network_calibrator.rs | 6 +++--- .../examples/simple_graphs.rs | 2 +- 3 files changed, 19 insertions(+), 10 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index fee4098..aee1001 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -886,6 +886,14 @@ dependencies = [ "unicode-segmentation", ] +[[package]] +name = "copy_span" +version = "0.1.0" +dependencies = [ + "proc-macro2", + "syn", +] + [[package]] name = "core-foundation" version = "0.10.1" @@ -1864,6 +1872,7 @@ dependencies = [ "bincode", "bytes", "clap", + "copy_span", "ctor 0.2.9", "data-encoding", "dfir_lang", @@ -4124,9 +4133,9 @@ checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" [[package]] name = "stageleft" -version = "0.10.0" +version = "0.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b92cb4d28ec3c2b3aba8ee05487f10c3aa00d7a369a3fe9d4d89e8719f28ca4f" +checksum = "101469d4cf8d54ac88b735ecd1dcc5e11da859e191a1dd0e28e71a298ffae1b9" dependencies = [ "ctor 0.4.3", "proc-macro-crate", @@ -4138,9 +4147,9 @@ dependencies = [ [[package]] name = "stageleft_macro" -version = "0.10.0" +version = "0.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e05624677c37d2abebe0c3e50fa7722f99936d26de2a8a23ac5d2a397be596c0" +checksum = "e1dc19da279ba29d00ae49363841037bd7c933130d0c4476899e1d7f8f04dab5" dependencies = [ "proc-macro-crate", "proc-macro2", @@ -4151,9 +4160,9 @@ dependencies = [ [[package]] name = "stageleft_tool" -version = "0.10.0" +version = "0.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da14207006ed0031a24197e0a2d3bc84b2a7ecf3a2ca70b70f1886cf1a37b464" +checksum = "977b4e22d5233ef274f43a02d9946dd4ee66c1957eac8a5f031450ab97bfa834" dependencies = [ "prettyplease", "proc-macro-crate", diff --git a/hydro_optimize_examples/examples/network_calibrator.rs b/hydro_optimize_examples/examples/network_calibrator.rs index 5688ad4..323ae35 100644 --- a/hydro_optimize_examples/examples/network_calibrator.rs +++ b/hydro_optimize_examples/examples/network_calibrator.rs @@ -36,8 +36,8 @@ async fn main() { }; let network = Arc::new(RwLock::new(GcpNetwork::new(&project, None))); - let num_clients = 5; // >1 clients so it doesn't become the bottleneck - let num_clients_per_node = 1; + let num_clients = 10; // >1 clients so it doesn't become the bottleneck + let num_clients_per_node = 1000; // Deploy let mut reusable_hosts = ReusableHosts { @@ -48,7 +48,7 @@ async fn main() { }; let message_sizes = vec![1, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192]; - let num_seconds_to_profile = Some(20); + let num_seconds_to_profile = Some(60); let multi_run_metadata = RefCell::new(vec![]); for message_size in message_sizes { diff --git a/hydro_optimize_examples/examples/simple_graphs.rs b/hydro_optimize_examples/examples/simple_graphs.rs index 48570ca..a2ad66a 100644 --- a/hydro_optimize_examples/examples/simple_graphs.rs +++ b/hydro_optimize_examples/examples/simple_graphs.rs @@ -89,7 +89,7 @@ async fn main() { }; let num_times_to_optimize = 2; - let num_seconds_to_profile = Some(20); + let num_seconds_to_profile = Some(60); let multi_run_metadata = RefCell::new(vec![]); for i in 0..num_times_to_optimize { From 86920b66acf4004e9727edb7ad328f1e248d7ea8 Mon Sep 17 00:00:00 2001 From: David Chu Date: Wed, 21 Jan 2026 20:54:06 -0800 Subject: [PATCH 13/35] Updating to latest API, WIP --- .vscode/settings.json | 3 + .../examples/network_calibrator.rs | 33 +- .../examples/simple_graphs.rs | 136 -- hydro_optimize_examples/src/lib.rs | 2 - hydro_optimize_examples/src/lock_server.rs | 100 +- .../src/network_calibrator.rs | 16 +- hydro_optimize_examples/src/simple_graphs.rs | 1175 ----------------- .../src/simple_graphs_bench.rs | 70 - .../src/simple_kv_bench.rs | 92 +- 9 files changed, 143 insertions(+), 1484 deletions(-) create mode 100644 .vscode/settings.json delete mode 100644 hydro_optimize_examples/examples/simple_graphs.rs delete mode 100644 hydro_optimize_examples/src/simple_graphs.rs delete mode 100644 hydro_optimize_examples/src/simple_graphs_bench.rs diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..23fd35f --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "editor.formatOnSave": true +} \ No newline at end of file diff --git a/hydro_optimize_examples/examples/network_calibrator.rs b/hydro_optimize_examples/examples/network_calibrator.rs index 323ae35..2961d48 100644 --- a/hydro_optimize_examples/examples/network_calibrator.rs +++ b/hydro_optimize_examples/examples/network_calibrator.rs @@ -14,14 +14,22 @@ use hydro_optimize_examples::network_calibrator::{Aggregator, Client, Server, ne use tokio::sync::RwLock; #[derive(Parser, Debug)] -#[command(author, version, about, long_about = None)] +#[command(author, version, about, long_about = None, group( + clap::ArgGroup::new("cloud") + .args(&["gcp", "aws"]) + .multiple(false) +))] struct Args { #[command(flatten)] graph: GraphConfig, - /// Use GCP for deployment (provide project name) + /// Use Gcp for deployment (provide project name) #[arg(long)] gcp: Option, + + /// Use Aws, make sure credentials are set up + #[arg(long, action = ArgAction::SetTrue)] + aws: bool, } #[tokio::main] @@ -29,24 +37,17 @@ async fn main() { let args = Args::parse(); let mut deployment = Deployment::new(); - let (host_arg, project) = if let Some(project) = args.gcp { - ("gcp".to_string(), project) + let host_type: HostType = if let Some(project) = args.gcp { + HostType::Gcp { project } + } else if args.aws { + HostType::Aws } else { - ("localhost".to_string(), String::new()) + HostType::Localhost }; - let network = Arc::new(RwLock::new(GcpNetwork::new(&project, None))); + let mut reusable_hosts = ReusableHosts::new(host_type); let num_clients = 10; // >1 clients so it doesn't become the bottleneck let num_clients_per_node = 1000; - - // Deploy - let mut reusable_hosts = ReusableHosts { - hosts: HashMap::new(), - host_arg, - project: project.clone(), - network: network.clone(), - }; - let message_sizes = vec![1, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192]; let num_seconds_to_profile = Some(60); let multi_run_metadata = RefCell::new(vec![]); @@ -87,7 +88,7 @@ async fn main() { deploy_and_analyze( &mut reusable_hosts, &mut deployment, - builder, + builder.finalize(), &clusters, &processes, vec![ diff --git a/hydro_optimize_examples/examples/simple_graphs.rs b/hydro_optimize_examples/examples/simple_graphs.rs deleted file mode 100644 index a2ad66a..0000000 --- a/hydro_optimize_examples/examples/simple_graphs.rs +++ /dev/null @@ -1,136 +0,0 @@ -use std::cell::RefCell; -use std::collections::HashMap; -use std::sync::Arc; - -use clap::Parser; -use hydro_deploy::Deployment; -use hydro_deploy::gcp::GcpNetwork; -use hydro_lang::viz::config::GraphConfig; -use hydro_lang::location::Location; -use hydro_lang::prelude::FlowBuilder; -use hydro_optimize::decoupler; -use hydro_optimize::deploy::ReusableHosts; -use hydro_optimize::deploy_and_analyze::deploy_and_analyze; -use hydro_optimize_examples::simple_graphs::{Client, Server, get_graph_function}; -use hydro_optimize_examples::simple_graphs_bench::{Aggregator, simple_graphs_bench, simple_graphs_bench_no_union}; -use tokio::sync::RwLock; - -#[derive(Parser, Debug)] -#[command(author, version, about, long_about = None)] -struct Args { - #[command(flatten)] - graph: GraphConfig, - - /// Use GCP for deployment (provide project name) - #[arg(long)] - gcp: Option, - - #[arg(long)] - function: String, -} - -#[tokio::main] -async fn main() { - let args = Args::parse(); - - let mut deployment = Deployment::new(); - let (host_arg, project) = if let Some(project) = args.gcp { - ("gcp".to_string(), project) - } else { - ("localhost".to_string(), String::new()) - }; - let network = Arc::new(RwLock::new(GcpNetwork::new(&project, None))); - - let mut builder = FlowBuilder::new(); - let num_clients = 10; - let num_clients_per_node = 1000; - let graph_function = get_graph_function(&args.function); - let server = builder.cluster(); - let clients = builder.cluster(); - let client_aggregator = builder.process(); - - simple_graphs_bench( - num_clients_per_node, - &server, - &clients, - &client_aggregator, - graph_function, - ); - // simple_graphs_bench_no_union( - // num_clients_per_node, - // &server, - // &clients, - // &client_aggregator, - // ); - - let mut clusters = vec![ - ( - server.id().raw_id(), - std::any::type_name::().to_string(), - 1, - ), - ( - clients.id().raw_id(), - std::any::type_name::().to_string(), - num_clients, - ), - ]; - let processes = vec![( - client_aggregator.id().raw_id(), - std::any::type_name::().to_string(), - )]; - - // Deploy - let mut reusable_hosts = ReusableHosts { - hosts: HashMap::new(), - host_arg, - project: project.clone(), - network: network.clone(), - }; - - let num_times_to_optimize = 2; - let num_seconds_to_profile = Some(60); - let multi_run_metadata = RefCell::new(vec![]); - - for i in 0..num_times_to_optimize { - let (rewritten_ir_builder, mut ir, mut decoupler, bottleneck_name, bottleneck_num_nodes) = - deploy_and_analyze( - &mut reusable_hosts, - &mut deployment, - builder, - &clusters, - &processes, - vec![ - std::any::type_name::().to_string(), - std::any::type_name::().to_string(), - ], - num_seconds_to_profile, - &multi_run_metadata, - i, - ) - .await; - - // Apply decoupling - let mut decoupled_cluster = None; - builder = rewritten_ir_builder.build_with(|builder| { - let new_cluster = builder.cluster::<()>(); - decoupler.decoupled_location = new_cluster.id().clone(); - decoupler::decouple(&mut ir, &decoupler, &multi_run_metadata, i); - decoupled_cluster = Some(new_cluster); - - ir - }); - if let Some(new_cluster) = decoupled_cluster { - clusters.push(( - new_cluster.id().raw_id(), - format!("{}_decouple_{}", bottleneck_name, i), - bottleneck_num_nodes, - )); - } - } - - let built = builder.finalize(); - - // Generate graphs if requested - _ = built.generate_graph_with_config(&args.graph, None); -} \ No newline at end of file diff --git a/hydro_optimize_examples/src/lib.rs b/hydro_optimize_examples/src/lib.rs index aebaec4..624b954 100644 --- a/hydro_optimize_examples/src/lib.rs +++ b/hydro_optimize_examples/src/lib.rs @@ -1,8 +1,6 @@ stageleft::stageleft_no_entry_crate!(); pub mod network_calibrator; -pub mod simple_graphs; -pub mod simple_graphs_bench; pub mod simple_kv_bench; pub mod lock_server; pub mod lobsters; diff --git a/hydro_optimize_examples/src/lock_server.rs b/hydro_optimize_examples/src/lock_server.rs index 90afb66..b424e89 100644 --- a/hydro_optimize_examples/src/lock_server.rs +++ b/hydro_optimize_examples/src/lock_server.rs @@ -2,65 +2,75 @@ use hydro_lang::{ live_collections::stream::NoOrder, location::{Location, MemberId}, nondet::nondet, - prelude::{Process, Stream, Unbounded}, + prelude::{KeyedStream, Process, Unbounded}, }; use stageleft::q; pub struct Server {} /// Lock server implementation as described in https://dl.acm.org/doi/pdf/10.1145/3341301.3359651, with the difference being that each server can hold multiple locks. -/// Clients send (virt_client_id, server_id, acquire) requesting a lock from the server. -/// -/// If acquire = true, then: -/// - If the server currently holds the lock, it returns (virt_client_id, server_id, true). -/// - Otherwise, it returns (virt_client_id, server_id, false). -/// -/// If acquire = false, then the client wants to release its lock. Return (virt_client_id, server_id, true). +/// * `acquires`: Stream of (virt_client_id, lock_id), requesting a lock from the server. If the server currently holds the lock, it returns (virt_client_id, lock_id, true). Otherwise, it returns (virt_client_id, lock_id, false). +/// * `releases`: Stream of (virt_client_id, lock_id), releasing a lock back to the server. Returns (virt_client_id, lock_id). +/// +/// Assumptions: +/// - No client will send a release message before it knows it has acquired the lock. +/// - Clients block on ACKs for outgoing messages; no client has 2 in-flight messages. #[expect(clippy::type_complexity, reason = "internal Lock Server code // TODO")] pub fn lock_server<'a, Client>( server: &Process<'a, Server>, - payloads: Stream<(MemberId, (u32, u32, bool)), Process<'a, Server>, Unbounded, NoOrder>, -) -> Stream<(MemberId, (u32, u32, bool)), Process<'a, Server>, Unbounded, NoOrder> { + acquires: KeyedStream< + MemberId, + (u32, u32), + Process<'a, Server>, + Unbounded, + NoOrder, + >, + releases: KeyedStream< + MemberId, + (u32, u32), + Process<'a, Server>, + Unbounded, + NoOrder, + >, +) -> (KeyedStream, (u32, u32, bool), Process<'a, Server>, Unbounded, NoOrder>, KeyedStream, (u32, u32), Process<'a, Server>, Unbounded, NoOrder>) { let server_tick = server.tick(); - let keyed_payloads = payloads.map(q!(|(client_id, (virt_client_id, server_id, acquire))| ( - server_id, - (client_id, virt_client_id, acquire) - ))); + let keyed_payloads = payloads + .entries() + .map(q!(|(client_id, (virt_client_id, lock_id, acquire))| ( + lock_id, + (client_id, virt_client_id, acquire) + ))) + .into_keyed(); let batched_payloads = keyed_payloads - .batch( - &server_tick, - nondet!(/** Need to check who currently owns the lock */), - ) - .assume_ordering(nondet!(/** First to acquire the lock wins */)); + .assume_ordering(nondet!(/** For each key, the first to acquire the lock wins */)); let lock_state = batched_payloads .clone() - .persist() - .into_keyed() - .reduce(q!( - |(curr_client_id, curr_virt_client_id, is_held_by_client), - (client_id, virt_client_id, acquire)| { - if acquire { - // If the lock is currently held by the server, give the client the lock - if !*is_held_by_client { - *curr_client_id = client_id; - *curr_virt_client_id = virt_client_id; - *is_held_by_client = true; - } - } else { - // If the client is releasing the lock and it holds it, give the lock back to the server - if *is_held_by_client - && *curr_virt_client_id == virt_client_id - && *curr_client_id == client_id - { - *is_held_by_client = false; + .across_ticks(|stream| { + stream.reduce(q!( + |(curr_client_id, curr_virt_client_id, is_held_by_client), + (client_id, virt_client_id, acquire)| { + if acquire { + // If the lock is currently held by the server, give the client the lock + if !*is_held_by_client { + *curr_client_id = client_id; + *curr_virt_client_id = virt_client_id; + *is_held_by_client = true; + } + } else { + // If the client is releasing the lock and it holds it, give the lock back to the server + if *is_held_by_client + && *curr_virt_client_id == virt_client_id + && *curr_client_id == client_id + { + *is_held_by_client = false; + } } } - } - )) - .entries(); - let results = batched_payloads.join(lock_state).all_ticks().map(q!(|( - server_id, + )) + }); + let results = batched_payloads.cross_singleton(lock_state).all_ticks().map(q!(|( + lock_id, ( (client_id, virt_client_id, acquire), (curr_client_id, curr_virt_client_id, is_held_by_client), @@ -70,10 +80,10 @@ pub fn lock_server<'a, Client>( let acquired = is_held_by_client && curr_client_id == client_id && curr_virt_client_id == virt_client_id; - (client_id, (virt_client_id, server_id, acquired)) + (client_id, (virt_client_id, lock_id, acquired)) } else { // Releasing always succeeds - (client_id, (virt_client_id, server_id, true)) + (client_id, (virt_client_id, lock_id, true)) } })); results diff --git a/hydro_optimize_examples/src/network_calibrator.rs b/hydro_optimize_examples/src/network_calibrator.rs index fc2f058..372166a 100644 --- a/hydro_optimize_examples/src/network_calibrator.rs +++ b/hydro_optimize_examples/src/network_calibrator.rs @@ -1,4 +1,8 @@ -use hydro_lang::{live_collections::stream::NoOrder, nondet::nondet, prelude::{Cluster, Process, Stream, Unbounded}}; +use hydro_lang::{ + live_collections::stream::NoOrder, + nondet::nondet, + prelude::{Cluster, Process, Stream, TCP, Unbounded}, +}; use hydro_std::bench_client::{bench_client, print_bench_results}; use stageleft::q; @@ -16,14 +20,12 @@ pub fn network_calibrator<'a>( ) { let bench_results = bench_client( clients, - |_client, payload_request| { - size_based_workload_generator(message_size, payload_request) - }, + |_client, payload_request| size_based_workload_generator(message_size, payload_request), |payloads| { // Server just echoes the payload payloads - .broadcast_bincode(server, nondet!(/** Test */)) - .demux_bincode(clients) + .broadcast(server, TCP.bincode(), nondet!(/** Test */)) + .demux(clients, TCP.bincode()) .values() }, num_clients_per_node, @@ -50,4 +52,4 @@ pub fn size_based_workload_generator<'a, Client>( let msg_size = message_size; (virtual_id, vec![0; msg_size]) })) -} \ No newline at end of file +} diff --git a/hydro_optimize_examples/src/simple_graphs.rs b/hydro_optimize_examples/src/simple_graphs.rs deleted file mode 100644 index dba95be..0000000 --- a/hydro_optimize_examples/src/simple_graphs.rs +++ /dev/null @@ -1,1175 +0,0 @@ -use hydro_lang::{ - live_collections::stream::NoOrder, - location::{Location, MemberId}, - nondet::nondet, - prelude::{Cluster, KeyedStream, Unbounded}, -}; -use sha2::{Digest, Sha256}; -use stageleft::q; - -pub struct Client {} -pub struct Server {} - -pub trait GraphFunction<'a>: - Fn( - &Cluster<'a, Server>, - KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> -{ -} - -impl<'a, F> GraphFunction<'a> for F where - F: Fn( - &Cluster<'a, Server>, - KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, - ) - -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> -{ -} - -fn sha256(n: u32) -> u32 { - let start_time = std::time::Instant::now(); - let mut sha_input = n; - - loop { - let mut sha = Sha256::new(); - sha.update(sha_input.to_be_bytes()); - let sha_output = sha.finalize(); - sha_input = sha_output[0].into(); - if start_time.elapsed().as_micros() >= n.into() { - break; - } - } - - sha_input -} - -// Note: H = high load, L = low load - -pub fn get_graph_function<'a>(name: &str) -> impl GraphFunction<'a> { - match name { - "noop" => noop, - "map_h_map_h" => map_h_map_h, - "map_h_map_h_split_up" => map_h_map_h_split_up, - "map_h_map_h_parallel" => map_h_map_h_parallel, - "map_h_map_h_map_h" => map_h_map_h_map_h, - "map_h_map_h_map_l" => map_h_map_h_map_l, - "map_h_map_l_map_h" => map_h_map_l_map_h, - "map_l_map_h_map_h" => map_l_map_h_map_h, - "map_h_map_l_map_l" => map_h_map_l_map_l, - "map_l_map_h_map_l" => map_l_map_h_map_l, - "map_l_map_l_map_h" => map_l_map_l_map_h, - "map_l_map_l_map_l" => map_l_map_l_map_l, - "map_l_first_map_l_second_union" => map_l_first_map_l_second_union, - "map_l_first_map_h_second_union" => map_l_first_map_h_second_union, - "map_h_first_map_l_second_union" => map_h_first_map_l_second_union, - "map_h_first_map_h_second_union" => map_h_first_map_h_second_union, - "map_l_map_l_first_payload_second_union" => map_l_map_l_first_payload_second_union, - "map_l_map_h_first_payload_second_union" => map_l_map_h_first_payload_second_union, - "map_h_map_l_first_payload_second_union" => map_h_map_l_first_payload_second_union, - "map_h_map_h_first_payload_second_union" => map_h_map_h_first_payload_second_union, - "map_l_first_payload_second_union_map_l" => map_l_first_payload_second_union_map_l, - "map_l_first_payload_second_union_map_h" => map_l_first_payload_second_union_map_h, - "map_h_first_payload_second_union_map_l" => map_h_first_payload_second_union_map_l, - "map_h_first_payload_second_union_map_h" => map_h_first_payload_second_union_map_h, - "map_l_first_map_l_second_anti_join" => map_l_first_map_l_second_anti_join, - "map_l_first_map_h_second_anti_join" => map_l_first_map_h_second_anti_join, - "map_h_first_map_l_second_anti_join" => map_h_first_map_l_second_anti_join, - "map_h_first_map_h_second_anti_join" => map_h_first_map_h_second_anti_join, - "map_l_map_l_first_payload_second_anti_join" => map_l_map_l_first_payload_second_anti_join, - "map_l_map_h_first_payload_second_anti_join" => map_l_map_h_first_payload_second_anti_join, - "map_h_map_l_first_payload_second_anti_join" => map_h_map_l_first_payload_second_anti_join, - "map_h_map_h_first_payload_second_anti_join" => map_h_map_h_first_payload_second_anti_join, - "map_l_first_payload_second_anti_join_map_l" => map_l_first_payload_second_anti_join_map_l, - "map_l_first_payload_second_anti_join_map_h" => map_l_first_payload_second_anti_join_map_h, - "map_h_first_payload_second_anti_join_map_l" => map_h_first_payload_second_anti_join_map_l, - "map_h_first_payload_second_anti_join_map_h" => map_h_first_payload_second_anti_join_map_h, - _ => unimplemented!(), - } -} - -pub fn noop<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - payloads -} - -pub fn map_h_map_h<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - payloads - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(100 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(100 + n % 2) - ))) -} - -pub fn map_h_map_h_split_up<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - payloads - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(10 + n % 2) - ))) -} - -pub fn map_h_map_h_parallel<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - let batch0 = payloads.clone().filter(q!(|(virt_client_id, _)| virt_client_id % 2 == 0)); - let batch1 = payloads.filter(q!(|(virt_client_id, _)| virt_client_id % 2 == 1)); - let batch0out = batch0 - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(100 + n % 2) - ))); - batch1 - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(100 + n % 2) - ))) - .interleave(batch0out) -} - -pub fn map_h_map_h_parallel_no_union<'a>( - _server: &Cluster<'a, Server>, - payloads1: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, - payloads2: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> (KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>) { - (payloads1 - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(100 + n % 2) - ))), - payloads2 - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(100 + n % 2) - )))) -} - -pub fn map_h_map_h_map_h<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - payloads - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(100 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(100 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(100 + n % 2) - ))) -} - -pub fn map_h_map_h_map_l<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - payloads - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(100 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(100 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(n % 2 + 1) - ))) -} - -pub fn map_h_map_l_map_h<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - payloads - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(100 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(n % 2 + 1) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(100 + n % 2) - ))) -} - -pub fn map_l_map_h_map_h<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - payloads - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(n % 2 + 1) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(100 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(100 + n % 2) - ))) -} - -pub fn map_h_map_l_map_l<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - payloads - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(100 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(n % 2 + 1) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(n % 2 + 1) - ))) -} - -pub fn map_l_map_h_map_l<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - payloads - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(n % 2 + 1) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(100 + n % 2) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(n % 2 + 1) - ))) -} - -pub fn map_l_map_l_map_h<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - payloads - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(n % 2 + 1) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(n % 2 + 1) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(100 + n % 2) - ))) -} - -pub fn map_l_map_l_map_l<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - payloads - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(n % 2 + 1) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(n % 2 + 1) - ))) - .map(q!(|(virt_client_id, n)| ( - virt_client_id, - self::sha256(n % 2 + 1) - ))) -} - -pub fn map_l_first_map_l_second_union<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - let map_l1 = payloads - .clone() - .map(q!(|(_virt_client_id, n)| (None, self::sha256(n % 2 + 1)))); - let map_l2 = payloads.map(q!(|(virt_client_id, n)| ( - Some(virt_client_id), - self::sha256(n % 2 + 1) - ))); - map_l1 - .interleave(map_l2) - .filter_map(q!(|(virt_client_id_opt, n)| { - // Since we cloned payloads, delete half the payloads so 1 input = 1 output - if let Some(virt_client_id) = virt_client_id_opt { - Some((virt_client_id, n)) - } else { - None - } - })) -} - -pub fn map_l_first_map_h_second_union<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - let map_l1 = payloads - .clone() - .map(q!(|(_virt_client_id, n)| (None, self::sha256(n % 2 + 1)))); - let map_h2 = payloads.map(q!(|(virt_client_id, n)| ( - Some(virt_client_id), - self::sha256(100 + n % 2) - ))); - map_l1 - .interleave(map_h2) - .filter_map(q!(|(virt_client_id_opt, n)| { - // Since we cloned payloads, delete half the payloads so 1 input = 1 output - if let Some(virt_client_id) = virt_client_id_opt { - Some((virt_client_id, n)) - } else { - None - } - })) -} - -pub fn map_h_first_map_l_second_union<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - let map_h1 = payloads - .clone() - .map(q!(|(_virt_client_id, n)| (None, self::sha256(100 + n % 2)))); - let map_l2 = payloads.map(q!(|(virt_client_id, n)| ( - Some(virt_client_id), - self::sha256(n % 2 + 1) - ))); - map_h1 - .interleave(map_l2) - .filter_map(q!(|(virt_client_id_opt, n)| { - // Since we cloned payloads, delete half the payloads so 1 input = 1 output - if let Some(virt_client_id) = virt_client_id_opt { - Some((virt_client_id, n)) - } else { - None - } - })) -} - -pub fn map_h_first_map_h_second_union<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - let map_h1 = payloads - .clone() - .map(q!(|(_virt_client_id, n)| (None, self::sha256(100 + n % 2)))); - let map_h2 = payloads.map(q!(|(virt_client_id, n)| ( - Some(virt_client_id), - self::sha256(100 + n % 2) - ))); - map_h1 - .interleave(map_h2) - .filter_map(q!(|(virt_client_id_opt, n)| { - // Since we cloned payloads, delete half the payloads so 1 input = 1 output - if let Some(virt_client_id) = virt_client_id_opt { - Some((virt_client_id, n)) - } else { - None - } - })) -} - -pub fn map_l_map_l_first_payload_second_union<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - payloads - .clone() - .map(q!(|(_virt_client_id, n)| ( - None::, - self::sha256(n % 2 + 1) - ))) - .map(q!(|(_virt_client_id, n)| (None, self::sha256(n % 2 + 1)))) - .interleave(payloads.map(q!(|(virt_client_id, n)| (Some(virt_client_id), n)))) - .filter_map(q!(|(virt_client_id_opt, n)| { - // Since we cloned payloads, delete half the payloads so 1 input = 1 output - if let Some(virt_client_id) = virt_client_id_opt { - Some((virt_client_id, n)) - } else { - None - } - })) -} - -pub fn map_l_map_h_first_payload_second_union<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - payloads - .clone() - .map(q!(|(_virt_client_id, n)| ( - None::, - self::sha256(n % 2 + 1) - ))) - .map(q!(|(_virt_client_id, n)| (None, self::sha256(100 + n % 2)))) - .interleave(payloads.map(q!(|(virt_client_id, n)| (Some(virt_client_id), n)))) - .filter_map(q!(|(virt_client_id_opt, n)| { - // Since we cloned payloads, delete half the payloads so 1 input = 1 output - if let Some(virt_client_id) = virt_client_id_opt { - Some((virt_client_id, n)) - } else { - None - } - })) -} - -pub fn map_h_map_l_first_payload_second_union<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - payloads - .clone() - .map(q!(|(_virt_client_id, n)| ( - None::, - self::sha256(100 + n % 2) - ))) - .map(q!(|(_virt_client_id, n)| (None, self::sha256(n % 2 + 1)))) - .interleave(payloads.map(q!(|(virt_client_id, n)| (Some(virt_client_id), n)))) - .filter_map(q!(|(virt_client_id_opt, n)| { - // Since we cloned payloads, delete half the payloads so 1 input = 1 output - if let Some(virt_client_id) = virt_client_id_opt { - Some((virt_client_id, n)) - } else { - None - } - })) -} - -pub fn map_h_map_h_first_payload_second_union<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - payloads - .clone() - .map(q!(|(_virt_client_id, n)| ( - None::, - self::sha256(100 + n % 2) - ))) - .map(q!(|(_virt_client_id, n)| (None, self::sha256(100 + n % 2)))) - .interleave(payloads.map(q!(|(virt_client_id, n)| (Some(virt_client_id), n)))) - .filter_map(q!(|(virt_client_id_opt, n)| { - // Since we cloned payloads, delete half the payloads so 1 input = 1 output - if let Some(virt_client_id) = virt_client_id_opt { - Some((virt_client_id, n)) - } else { - None - } - })) -} - -pub fn map_l_first_payload_second_union_map_l<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - payloads - .clone() - .map(q!(|(_virt_client_id, n)| ( - None::, - self::sha256(n % 2 + 1) - ))) - .interleave(payloads.map(q!(|(virt_client_id, n)| (Some(virt_client_id), n)))) - .filter_map(q!(|(virt_client_id_opt, n)| { - let sha = self::sha256(n % 2 + 1); - // Since we cloned payloads, delete half the payloads so 1 input = 1 output - if let Some(virt_client_id) = virt_client_id_opt { - Some((virt_client_id, sha)) - } else { - None - } - })) -} - -pub fn map_l_first_payload_second_union_map_h<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - payloads - .clone() - .map(q!(|(_virt_client_id, n)| ( - None::, - self::sha256(n % 2 + 1) - ))) - .interleave(payloads.map(q!(|(virt_client_id, n)| (Some(virt_client_id), n)))) - .filter_map(q!(|(virt_client_id_opt, n)| { - let sha = self::sha256(100 + n % 2); - // Since we cloned payloads, delete half the payloads so 1 input = 1 output - if let Some(virt_client_id) = virt_client_id_opt { - Some((virt_client_id, sha)) - } else { - None - } - })) -} - -pub fn map_h_first_payload_second_union_map_l<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - payloads - .clone() - .map(q!(|(_virt_client_id, n)| ( - None::, - self::sha256(100 + n % 2) - ))) - .interleave(payloads.map(q!(|(virt_client_id, n)| (Some(virt_client_id), n)))) - .filter_map(q!(|(virt_client_id_opt, n)| { - let sha = self::sha256(n % 2 + 1); - // Since we cloned payloads, delete half the payloads so 1 input = 1 output - if let Some(virt_client_id) = virt_client_id_opt { - Some((virt_client_id, sha)) - } else { - None - } - })) -} - -pub fn map_h_first_payload_second_union_map_h<'a>( - _server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - payloads - .clone() - .map(q!(|(_virt_client_id, n)| ( - None::, - self::sha256(100 + n % 2) - ))) - .interleave(payloads.map(q!(|(virt_client_id, n)| (Some(virt_client_id), n)))) - .filter_map(q!(|(virt_client_id_opt, n)| { - let sha = self::sha256(100 + n % 2); - // Since we cloned payloads, delete half the payloads so 1 input = 1 output - if let Some(virt_client_id) = virt_client_id_opt { - Some((virt_client_id, sha)) - } else { - None - } - })) -} - -pub fn map_l_first_map_l_second_anti_join<'a>( - server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - let tick = server.tick(); - let nondet = nondet!(/** Test */); - - let true_payloads = payloads - .clone() - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - true, - n - ))); - let map_l1 = payloads - .clone() - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - false, - self::sha256(n % 2 + 1) - ))) - .interleave(true_payloads) // The actual payloads that will pass the anti_join - .batch(&tick, nondet); - let map_l2 = payloads - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - false, - self::sha256(n % 2 + 1) - ))) - .batch(&tick, nondet); - map_l1 - .filter_not_in(map_l2) - .all_ticks() - .filter_map(q!(|(client_id, virt_client_id, keep, n)| { - if keep { - Some((client_id, (virt_client_id, n))) - } else { - None - } - })) - .into_keyed() -} - -pub fn map_l_first_map_h_second_anti_join<'a>( - server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - let tick = server.tick(); - let nondet = nondet!(/** Test */); - - let true_payloads = payloads - .clone() - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - true, - n - ))); - let map_l1 = payloads - .clone() - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - false, - self::sha256(n % 2 + 1) - ))) - .interleave(true_payloads) // The actual payloads that will pass the anti_join - .batch(&tick, nondet); - let map_h2 = payloads - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - false, - self::sha256(100 + n % 2) - ))) - .batch(&tick, nondet); - map_l1 - .filter_not_in(map_h2) - .all_ticks() - .filter_map(q!(|(client_id, virt_client_id, keep, n)| { - if keep { - Some((client_id, (virt_client_id, n))) - } else { - None - } - })) - .into_keyed() -} - -pub fn map_h_first_map_l_second_anti_join<'a>( - server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - let tick = server.tick(); - let nondet = nondet!(/** Test */); - - let true_payloads = payloads - .clone() - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - true, - n - ))); - let map_h1 = payloads - .clone() - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - false, - self::sha256(100 + n % 2) - ))) - .interleave(true_payloads) // The actual payloads that will pass the anti_join - .batch(&tick, nondet); - let map_l2 = payloads - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - false, - self::sha256(n % 2 + 1) - ))) - .batch(&tick, nondet); - map_h1 - .filter_not_in(map_l2) - .all_ticks() - .filter_map(q!(|(client_id, virt_client_id, keep, n)| { - if keep { - Some((client_id, (virt_client_id, n))) - } else { - None - } - })) - .into_keyed() -} - -pub fn map_h_first_map_h_second_anti_join<'a>( - server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - let tick = server.tick(); - let nondet = nondet!(/** Test */); - - let true_payloads = payloads - .clone() - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - true, - n - ))); - let map_h1 = payloads - .clone() - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - false, - self::sha256(100 + n % 2) - ))) - .interleave(true_payloads) // The actual payloads that will pass the anti_join - .batch(&tick, nondet); - let map_h2 = payloads - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - false, - self::sha256(100 + n % 2) - ))) - .batch(&tick, nondet); - map_h1 - .filter_not_in(map_h2) - .all_ticks() - .filter_map(q!(|(client_id, virt_client_id, keep, n)| { - if keep { - Some((client_id, (virt_client_id, n))) - } else { - None - } - })) - .into_keyed() -} - -pub fn map_l_map_l_first_payload_second_anti_join<'a>( - server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - let tick = server.tick(); - let nondet = nondet!(/** Test */); - - let false_payloads = payloads - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - n, - false - ))); - false_payloads - .clone() - .map(q!(|(client_id, virt_client_id, n, _keep)| ( - client_id, - virt_client_id, - self::sha256(n % 2 + 1), - true - ))) - .map(q!(|(client_id, virt_client_id, n, _keep)| ( - client_id, - virt_client_id, - self::sha256(n % 2 + 1), - true - ))) - .interleave(false_payloads.clone()) - .batch(&tick, nondet) - .filter_not_in(false_payloads.batch(&tick, nondet)) - .all_ticks() - .filter_map(q!(|(client_id, virt_client_id, n, keep)| { - if keep { - Some((client_id, (virt_client_id, n))) - } else { - None - } - })) - .into_keyed() -} - -pub fn map_l_map_h_first_payload_second_anti_join<'a>( - server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - let tick = server.tick(); - let nondet = nondet!(/** Test */); - - let false_payloads = payloads - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - n, - false - ))); - false_payloads - .clone() - .map(q!(|(client_id, virt_client_id, n, _keep)| ( - client_id, - virt_client_id, - self::sha256(n % 2 + 1), - true - ))) - .map(q!(|(client_id, virt_client_id, n, _keep)| ( - client_id, - virt_client_id, - self::sha256(100 + n % 2), - true - ))) - .interleave(false_payloads.clone()) - .batch(&tick, nondet) - .filter_not_in(false_payloads.batch(&tick, nondet)) - .all_ticks() - .filter_map(q!(|(client_id, virt_client_id, n, keep)| { - if keep { - Some((client_id, (virt_client_id, n))) - } else { - None - } - })) - .into_keyed() -} - -pub fn map_h_map_l_first_payload_second_anti_join<'a>( - server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - let tick = server.tick(); - let nondet = nondet!(/** Test */); - - let false_payloads = payloads - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - n, - false - ))); - false_payloads - .clone() - .map(q!(|(client_id, virt_client_id, n, _keep)| ( - client_id, - virt_client_id, - self::sha256(100 + n % 2), - true - ))) - .map(q!(|(client_id, virt_client_id, n, _keep)| ( - client_id, - virt_client_id, - self::sha256(n % 2 + 1), - true - ))) - .interleave(false_payloads.clone()) - .batch(&tick, nondet) - .filter_not_in(false_payloads.batch(&tick, nondet)) - .all_ticks() - .filter_map(q!(|(client_id, virt_client_id, n, keep)| { - if keep { - Some((client_id, (virt_client_id, n))) - } else { - None - } - })) - .into_keyed() -} - -pub fn map_h_map_h_first_payload_second_anti_join<'a>( - server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - let tick = server.tick(); - let nondet = nondet!(/** Test */); - - let false_payloads = payloads - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - n, - false - ))); - false_payloads - .clone() - .map(q!(|(client_id, virt_client_id, n, _keep)| ( - client_id, - virt_client_id, - self::sha256(100 + n % 2), - true - ))) - .map(q!(|(client_id, virt_client_id, n, _keep)| ( - client_id, - virt_client_id, - self::sha256(100 + n % 2), - true - ))) - .interleave(false_payloads.clone()) - .batch(&tick, nondet) - .filter_not_in(false_payloads.batch(&tick, nondet)) - .all_ticks() - .filter_map(q!(|(client_id, virt_client_id, n, keep)| { - if keep { - Some((client_id, (virt_client_id, n))) - } else { - None - } - })) - .into_keyed() -} - -pub fn map_l_first_payload_second_anti_join_map_l<'a>( - server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - let tick = server.tick(); - let nondet = nondet!(/** Test */); - - let false_payloads = payloads - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - n, - false - ))); - - false_payloads - .clone() - .map(q!(|(client, virt_client_id, n, _keep)| ( - client, - virt_client_id, - self::sha256(n % 2 + 1), - true - ))) - .interleave(false_payloads.clone()) - .batch(&tick, nondet) - .filter_not_in(false_payloads.clone().batch(&tick, nondet)) - .all_ticks() - .filter_map(q!(|(client, virt_client_id, n, keep)| { - if keep { - Some((client, (virt_client_id, self::sha256(n % 2 + 1)))) - } else { - None - } - })) - .into_keyed() -} - -pub fn map_l_first_payload_second_anti_join_map_h<'a>( - server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - let tick = server.tick(); - let nondet = nondet!(/** Test */); - - let false_payloads = payloads - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - n, - false - ))); - - false_payloads - .clone() - .map(q!(|(client, virt_client_id, n, _keep)| ( - client, - virt_client_id, - self::sha256(n % 2 + 1), - true - ))) - .interleave(false_payloads.clone()) - .batch(&tick, nondet) - .filter_not_in(false_payloads.clone().batch(&tick, nondet)) - .all_ticks() - .filter_map(q!(|(client, virt_client_id, n, keep)| { - if keep { - Some((client, (virt_client_id, self::sha256(100 + n % 2)))) - } else { - None - } - })) - .into_keyed() -} - -pub fn map_h_first_payload_second_anti_join_map_l<'a>( - server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - let tick = server.tick(); - let nondet = nondet!(/** Test */); - - let false_payloads = payloads - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - n, - false - ))); - - false_payloads - .clone() - .map(q!(|(client, virt_client_id, n, _keep)| ( - client, - virt_client_id, - self::sha256(100 + n % 2), - true - ))) - .interleave(false_payloads.clone()) - .batch(&tick, nondet) - .filter_not_in(false_payloads.clone().batch(&tick, nondet)) - .all_ticks() - .filter_map(q!(|(client, virt_client_id, n, keep)| { - if keep { - Some((client, (virt_client_id, self::sha256(n % 2 + 1)))) - } else { - None - } - })) - .into_keyed() -} - -pub fn map_h_first_payload_second_anti_join_map_h<'a>( - server: &Cluster<'a, Server>, - payloads: KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder>, -) -> KeyedStream, (u32, u32), Cluster<'a, Server>, Unbounded, NoOrder> { - let tick = server.tick(); - let nondet = nondet!(/** Test */); - - let false_payloads = payloads - .entries() - .map(q!(|(client_id, (virt_client_id, n))| ( - client_id, - virt_client_id, - n, - false - ))); - - false_payloads - .clone() - .map(q!(|(client, virt_client_id, n, _keep)| ( - client, - virt_client_id, - self::sha256(100 + n % 2), - true - ))) - .interleave(false_payloads.clone()) - .batch(&tick, nondet) - .filter_not_in(false_payloads.clone().batch(&tick, nondet)) - .all_ticks() - .filter_map(q!(|(client, virt_client_id, n, keep)| { - if keep { - Some((client, (virt_client_id, self::sha256(100 + n % 2)))) - } else { - None - } - })) - .into_keyed() -} diff --git a/hydro_optimize_examples/src/simple_graphs_bench.rs b/hydro_optimize_examples/src/simple_graphs_bench.rs deleted file mode 100644 index 57ae990..0000000 --- a/hydro_optimize_examples/src/simple_graphs_bench.rs +++ /dev/null @@ -1,70 +0,0 @@ -use hydro_lang::{prelude::{Cluster, Process}, nondet::nondet}; -use hydro_std::bench_client::{bench_client, print_bench_results}; - -use hydro_test::cluster::paxos_bench::inc_u32_workload_generator; -use stageleft::q; -use crate::simple_graphs::{Client, GraphFunction, Server, map_h_map_h_parallel_no_union}; -pub struct Aggregator; - -pub fn simple_graphs_bench<'a>( - num_clients_per_node: usize, - server: &Cluster<'a, Server>, - clients: &Cluster<'a, Client>, - client_aggregator: &Process<'a, Aggregator>, - graph: impl GraphFunction<'a>, -) { - let bench_results = bench_client( - clients, - inc_u32_workload_generator, - |payloads| { - graph( - server, - payloads - .broadcast_bincode(server, nondet!(/** Test */)) - .into(), - ) - .demux_bincode(clients) - .values() - }, - num_clients_per_node, - nondet!(/** bench */), - ); - - print_bench_results(bench_results, client_aggregator, clients); -} - -pub fn simple_graphs_bench_no_union<'a>( - num_clients_per_node: usize, - server: &Cluster<'a, Server>, - clients: &Cluster<'a, Client>, - client_aggregator: &Process<'a, Aggregator>, -) { - let bench_results = bench_client( - clients, - inc_u32_workload_generator, - |payloads| { - let payloads1 = payloads.clone().filter(q!(|(virt_client_id, _)| virt_client_id % 2 == 0)); - let payloads2 = payloads.filter(q!(|(virt_client_id, _)| virt_client_id % 2 == 1)); - let (batch0, batch1) = map_h_map_h_parallel_no_union( - server, - payloads1 - .broadcast_bincode(server, nondet!(/** Test */)) - .into(), - payloads2 - .broadcast_bincode(server, nondet!(/** Test */)) - .into(), - ); - let clients_batch0 = batch0 - .demux_bincode(clients) - .values(); - batch1 - .demux_bincode(clients) - .values() - .interleave(clients_batch0) - }, - num_clients_per_node, - nondet!(/** bench */), - ); - - print_bench_results(bench_results, client_aggregator, clients); -} \ No newline at end of file diff --git a/hydro_optimize_examples/src/simple_kv_bench.rs b/hydro_optimize_examples/src/simple_kv_bench.rs index da8e1f9..eee9ccd 100644 --- a/hydro_optimize_examples/src/simple_kv_bench.rs +++ b/hydro_optimize_examples/src/simple_kv_bench.rs @@ -1,7 +1,9 @@ +use std::time::SystemTime; + use hydro_lang::{ location::Location, nondet::nondet, - prelude::{Cluster, Process}, + prelude::{Cluster, Process, TCP}, }; use hydro_std::bench_client::{bench_client, print_bench_results}; @@ -18,36 +20,60 @@ pub fn simple_kv_bench<'a>( clients: &Cluster<'a, Client>, client_aggregator: &Process<'a, Aggregator>, ) { - let bench_results = bench_client( - clients, - inc_u32_workload_generator, - |payloads| { - let k_tick = kv.tick(); - let k_payloads = payloads.send_bincode(kv).batch(&k_tick, nondet!(/** TODO: Actually can use atomic() here, but there's no way to exit atomic in KeyedStreams? */)); - - // Insert each payload into the KV store - k_payloads - .clone() - .values() - .assume_ordering(nondet!(/** Last writer wins. TODO: Technically, we only need to assume ordering over the keyed stream (ordering of values with different keys doesn't matter. But there's no .persist() for KeyedStreams) */)) - .persist() - .into_keyed() - .reduce(q!(|prev, new| { - *prev = new; - })) - .entries() - .all_ticks() - .assume_ordering(nondet!(/** for_each does nothing, just need to end on a HydroLeaf */)) - .assume_retries(nondet!(/** for_each does nothing, just need to end on a HydroLeaf */)) - .for_each(q!(|_| {})); // Do nothing, just need to end on a HydroLeaf - - // Send committed requests back to the original client - k_payloads.all_ticks().demux_bincode(clients).into() - }, - num_clients_per_node, - nondet!(/** bench */), - ); - + // Set up client that auto-generates requests with virtual IDs + let (c_received_payloads_complete, c_received_payloads) = clients.forward_ref(); + let c_new_payload_ids = bench_client(clients, num_clients_per_node, c_received_payloads); + + // Attach payloads to requests + let c_payloads = c_new_payload_ids.map(q!(move |payload| { + let value = if let Some((counter, _time)) = payload { + counter + 1 + } else { + 0 + }; + // Record current time for latency + (value, SystemTime::now()) + })); + + // Protocol + let k_tick = kv.tick(); + // Use atomic to prevent outputting to the client before values are inserted to the KV store + let k_payloads = c_payloads.send(kv, TCP.bincode()).atomic(&k_tick); + + let for_each_tick = kv.tick(); + // Insert each payload into the KV store + k_payloads + .clone() + .assume_ordering(nondet!(/** Last writer wins per key. */)) + // Persist state across ticks + .reduce(q!(|prev, new| { + *prev = new; + })) + .end_atomic() + .snapshot( + &for_each_tick, + nondet!(/** for_each does nothing, just need to end on a HydroRoot */), + ) + .entries() + .all_ticks() + .assume_ordering(nondet!(/** for_each does nothing, just need to end on a HydroRoot */)) + .assume_retries(nondet!(/** for_each does nothing, just need to end on a HydroRoot */)) + .for_each(q!(|_| {})); // Do nothing, just need to end on a HydroRoot + + // Send committed requests back to the original client + let completed_payloads = k_payloads + .end_atomic() + .demux(clients, TCP.bincode()) + .into_keyed(); + + // Send committed requests back to the original client + c_received_payloads_complete.complete(completed_payloads.clone()); + + // Create throughput/latency graphs + let latencies = completed_payloads.values().map(q!(move |(_counter, time)| { + SystemTime::now().duration_since(time).unwrap() + })); + let bench_results = compute_throughput_latency(clients, latencies, nondet!(/** bench */)); print_bench_results(bench_results, client_aggregator, clients); } @@ -76,7 +102,7 @@ mod tests { let client_aggregator = builder.process(); simple_kv_bench(1, &kv, &clients, &client_aggregator); - let built = builder.with_default_optimize::(); + let mut built = builder.with_default_optimize::(); dbg_dedup_tee(|| { insta::assert_debug_snapshot!(built.ir()); @@ -118,7 +144,7 @@ mod tests { deployment.deploy().await.unwrap(); let client_node = &nodes.get_process(&client_aggregator); - let client_out = client_node.stdout_filter("Throughput:").await; + let client_out = client_node.stdout_filter("Throughput:"); deployment.start().await.unwrap(); From 179bf36b091bfc0c1b3a6f126b1d0cf608683400 Mon Sep 17 00:00:00 2001 From: David Chu Date: Fri, 23 Jan 2026 01:37:42 +0000 Subject: [PATCH 14/35] Migrating to latest Hydro, WIP --- Cargo.lock | 318 ++++++++---------- Cargo.toml | 6 +- hydro_optimize/src/debug.rs | 3 +- hydro_optimize/src/parse_results.rs | 7 +- hydro_optimize/src/tests/two_pc.rs | 2 +- .../examples/benchmark_paxos.rs | 6 +- hydro_optimize_examples/src/lobsters.rs | 87 ++--- hydro_optimize_examples/src/lock_server.rs | 186 +++++++--- .../src/network_calibrator.rs | 32 +- .../src/simple_kv_bench.rs | 90 ++--- 10 files changed, 388 insertions(+), 349 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 237570e..255f239 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -291,7 +291,7 @@ version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b681c58ec6001e5385fb80647299e8a5f796d17ab33ffe81a17408899f008208" dependencies = [ - "thiserror 2.0.17", + "thiserror 2.0.18", ] [[package]] @@ -332,7 +332,7 @@ dependencies = [ "async-promise", "russh", "russh-sftp", - "thiserror 2.0.17", + "thiserror 2.0.18", "tokio", "tracing", ] @@ -657,9 +657,9 @@ dependencies = [ [[package]] name = "cc" -version = "1.2.52" +version = "1.2.53" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd4932aefd12402b36c60956a4fe0035421f544799057659ff86f923657aada3" +checksum = "755d2fce177175ffca841e9a06afdb2c4ab0f593d53b4dee48147dfaade85932" dependencies = [ "find-msvc-tools", "shlex", @@ -705,9 +705,9 @@ dependencies = [ [[package]] name = "chrono" -version = "0.4.42" +version = "0.4.43" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2" +checksum = "fac4744fb15ae8337dc853fee7fb3f4e48c0fbaa23d0afe49c447b4fab126118" dependencies = [ "iana-time-zone", "js-sys", @@ -773,9 +773,9 @@ dependencies = [ [[package]] name = "clap_lex" -version = "0.7.6" +version = "0.7.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d" +checksum = "c3e64b0cc0439b12df2fa678eae89a1c56a529fd067a9115f7827f1fffd22b32" [[package]] name = "cmake" @@ -794,11 +794,11 @@ checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75" [[package]] name = "colored" -version = "3.0.0" +version = "3.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fde0e0ec90c9dfb3b4b1a0891a7dcd0e2bffde2f7efed5fe7c9bb00e5bfb915e" +checksum = "faf9468729b8cbcea668e36183cb69d317348c2e08e994829fb56ebfdfbaac34" dependencies = [ - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -895,7 +895,7 @@ dependencies = [ [[package]] name = "copy_span" version = "0.1.0" -source = "git+https://github.com/hydro-project/hydro.git#17bd0540e496733c64527f9a0ef63b2b0bf47380" +source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" dependencies = [ "proc-macro2", "syn", @@ -1065,20 +1065,6 @@ dependencies = [ "syn", ] -[[package]] -name = "dashmap" -version = "6.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf" -dependencies = [ - "cfg-if", - "crossbeam-utils", - "hashbrown 0.14.5", - "lock_api", - "once_cell", - "parking_lot_core", -] - [[package]] name = "data-encoding" version = "2.10.0" @@ -1128,7 +1114,7 @@ dependencies = [ [[package]] name = "dfir_lang" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#17bd0540e496733c64527f9a0ef63b2b0bf47380" +source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" dependencies = [ "auto_impl", "documented", @@ -1173,7 +1159,7 @@ dependencies = [ "libc", "option-ext", "redox_users", - "windows-sys 0.61.2", + "windows-sys 0.59.0", ] [[package]] @@ -1195,7 +1181,7 @@ checksum = "ed6b3e31251e87acd1b74911aed84071c8364fc9087972748ade2f1094ccce34" dependencies = [ "documented-macros", "phf 0.12.1", - "thiserror 2.0.17", + "thiserror 2.0.18", ] [[package]] @@ -1234,12 +1220,6 @@ version = "1.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813" -[[package]] -name = "dyn-clone" -version = "1.0.20" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555" - [[package]] name = "ecdsa" version = "0.16.9" @@ -1334,23 +1314,10 @@ dependencies = [ ] [[package]] -name = "env_filter" -version = "0.1.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1bf3c259d255ca70051b30e2e95b5446cdb8949ac4cd22c0d7fd634d89f568e2" -dependencies = [ - "log", -] - -[[package]] -name = "env_logger" -version = "0.11.8" +name = "env_home" +version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "13c863f0904021b108aa8b2f55046443e6b1ebde8fd4a15c399893aae4fa069f" -dependencies = [ - "env_filter", - "log", -] +checksum = "c7f84e12ccf0a7ddc17a6c41c93326024c42920d7ee630d04950e6926645c0fe" [[package]] name = "equivalent" @@ -1425,9 +1392,9 @@ checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d" [[package]] name = "find-msvc-tools" -version = "0.1.7" +version = "0.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f449e6c6c08c865631d4890cfacf252b3d396c9bcc83adb6623cdb02a8336c41" +checksum = "8591b0bcc8a98a64310a2fae1bb3e9b8564dd10e381e6e28010fde8e8e8568db" [[package]] name = "flate2" @@ -1813,7 +1780,7 @@ checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" [[package]] name = "hydro_build_utils" version = "0.0.1" -source = "git+https://github.com/hydro-project/hydro.git#17bd0540e496733c64527f9a0ef63b2b0bf47380" +source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" dependencies = [ "insta", "rustc_version", @@ -1822,7 +1789,7 @@ dependencies = [ [[package]] name = "hydro_deploy" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#17bd0540e496733c64527f9a0ef63b2b0bf47380" +source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" dependencies = [ "anyhow", "append-only-vec", @@ -1835,7 +1802,6 @@ dependencies = [ "bytes", "cargo_metadata", "dunce", - "dyn-clone", "futures", "hydro_deploy_integration", "indicatif", @@ -1847,19 +1813,19 @@ dependencies = [ "nix", "serde", "serde_json", - "serde_path_to_error", "shell-escape", "tempfile", "tokio", "tokio-stream", "tokio-util", + "which", "wholesym", ] [[package]] name = "hydro_deploy_integration" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#17bd0540e496733c64527f9a0ef63b2b0bf47380" +source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" dependencies = [ "async-recursion", "async-trait", @@ -1877,7 +1843,7 @@ dependencies = [ [[package]] name = "hydro_lang" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#17bd0540e496733c64527f9a0ef63b2b0bf47380" +source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" dependencies = [ "auto_impl", "backtrace", @@ -1896,7 +1862,6 @@ dependencies = [ "hydro_deploy", "hydro_deploy_integration", "itertools 0.13.0", - "match_box", "nameof", "prettyplease", "proc-macro-crate", @@ -1907,6 +1872,7 @@ dependencies = [ "serde_json", "sha2", "sinktools", + "slotmap", "stageleft", "stageleft_tool", "syn", @@ -1968,7 +1934,7 @@ dependencies = [ [[package]] name = "hydro_std" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#17bd0540e496733c64527f9a0ef63b2b0bf47380" +source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" dependencies = [ "hdrhistogram", "hydro_lang", @@ -1980,7 +1946,7 @@ dependencies = [ [[package]] name = "hydro_test" version = "0.0.0" -source = "git+https://github.com/hydro-project/hydro.git#17bd0540e496733c64527f9a0ef63b2b0bf47380" +source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" dependencies = [ "bytes", "colored", @@ -1994,6 +1960,7 @@ dependencies = [ "stageleft", "stageleft_tool", "tokio", + "tokio-stream", ] [[package]] @@ -2187,7 +2154,7 @@ dependencies = [ [[package]] name = "include_mdtests" version = "0.0.0" -source = "git+https://github.com/hydro-project/hydro.git#17bd0540e496733c64527f9a0ef63b2b0bf47380" +source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" dependencies = [ "glob", "proc-macro2", @@ -2225,12 +2192,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "232929e1d75fe899576a3d5c7416ad0d88dbfbb3c3d6aa00873a7408a50ddb88" dependencies = [ "ahash", - "clap", - "crossbeam-channel", - "crossbeam-utils", - "dashmap", - "env_logger", - "indexmap", "is-terminal", "itoa", "log", @@ -2262,9 +2223,9 @@ dependencies = [ [[package]] name = "insta" -version = "1.46.0" +version = "1.46.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1b66886d14d18d420ab5052cbff544fc5d34d0b2cdd35eb5976aaa10a4a472e5" +checksum = "248b42847813a1550dafd15296fd9748c651d0c32194559dbc05d804d54b21e8" dependencies = [ "console", "once_cell", @@ -2324,7 +2285,7 @@ checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46" dependencies = [ "hermit-abi", "libc", - "windows-sys 0.61.2", + "windows-sys 0.59.0", ] [[package]] @@ -2381,9 +2342,9 @@ checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130" [[package]] name = "js-sys" -version = "0.3.83" +version = "0.3.85" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "464a3709c7f55f1f721e5389aa6ea4e3bc6aba669353300af094b29ffbdde1d8" +checksum = "8c942ebf8e95485ca0d52d97da7c5a2c387d0e7f0ba4c35e93bfcaee045955b3" dependencies = [ "once_cell", "wasm-bindgen", @@ -2448,7 +2409,7 @@ dependencies = [ "memchr", "prost", "prost-derive", - "thiserror 2.0.17", + "thiserror 2.0.18", ] [[package]] @@ -2460,7 +2421,7 @@ dependencies = [ "bitflags", "byteorder", "memchr", - "thiserror 2.0.17", + "thiserror 2.0.18", ] [[package]] @@ -2518,22 +2479,11 @@ version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bb4bdc8b0ce69932332cf76d24af69c3a155242af95c226b2ab6c2e371ed1149" dependencies = [ - "thiserror 2.0.17", + "thiserror 2.0.18", "zerocopy", "zerocopy-derive", ] -[[package]] -name = "match_box" -version = "0.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c33c1d4fa92364abfc42bcc58c201cfbb63ae80f5e471aac5c051db48dab6843" -dependencies = [ - "proc-macro2", - "quote", - "syn", -] - [[package]] name = "matchers" version = "0.2.0" @@ -2973,7 +2923,7 @@ dependencies = [ "maybe-owned", "pdb2", "range-collections", - "thiserror 2.0.17", + "thiserror 2.0.18", ] [[package]] @@ -3244,9 +3194,9 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.105" +version = "1.0.106" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "535d180e0ecab6268a3e718bb9fd44db66bbbc256257165fc699dadf70d16fe7" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" dependencies = [ "unicode-ident", ] @@ -3267,7 +3217,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d" dependencies = [ "anyhow", - "itertools 0.14.0", + "itertools 0.13.0", "proc-macro2", "quote", "syn", @@ -3296,7 +3246,7 @@ dependencies = [ "rustc-hash", "rustls", "socket2", - "thiserror 2.0.17", + "thiserror 2.0.18", "tokio", "tracing", "web-time", @@ -3317,7 +3267,7 @@ dependencies = [ "rustls", "rustls-pki-types", "slab", - "thiserror 2.0.17", + "thiserror 2.0.18", "tinyvec", "tracing", "web-time", @@ -3334,7 +3284,7 @@ dependencies = [ "once_cell", "socket2", "tracing", - "windows-sys 0.60.2", + "windows-sys 0.59.0", ] [[package]] @@ -3370,7 +3320,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1" dependencies = [ "rand_chacha 0.9.0", - "rand_core 0.9.4", + "rand_core 0.9.5", ] [[package]] @@ -3390,7 +3340,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" dependencies = [ "ppv-lite86", - "rand_core 0.9.4", + "rand_core 0.9.5", ] [[package]] @@ -3404,9 +3354,9 @@ dependencies = [ [[package]] name = "rand_core" -version = "0.9.4" +version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4f1b3bc831f92381018fd9c6350b917c7b21f1eed35a65a51900e0e55a3d7afa" +checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c" dependencies = [ "getrandom 0.3.4", ] @@ -3446,7 +3396,7 @@ checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac" dependencies = [ "getrandom 0.2.17", "libredox", - "thiserror 2.0.17", + "thiserror 2.0.18", ] [[package]] @@ -3682,7 +3632,7 @@ dependencies = [ "flurry", "log", "serde", - "thiserror 2.0.17", + "thiserror 2.0.18", "tokio", "tokio-util", ] @@ -3701,9 +3651,9 @@ dependencies = [ [[package]] name = "rustc-demangle" -version = "0.1.26" +version = "0.1.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56f7d92ca342cea22a06f2121d944b4fd82af56988c270852495420f961d4ace" +checksum = "b50b8869d9fc858ce7266cce0194bd74df58b9d0e3f6df3a9fc8eb470d95c09d" [[package]] name = "rustc-hash" @@ -3749,9 +3699,9 @@ dependencies = [ [[package]] name = "rustls-pki-types" -version = "1.13.2" +version = "1.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "21e6f2ab2928ca4291b86736a8bd920a277a399bba1589409d72154ff87c1282" +checksum = "be040f8b0a225e40375822a563fa9524378b9d63112f53e19ffff34df5d33fdd" dependencies = [ "web-time", "zeroize", @@ -3759,9 +3709,9 @@ dependencies = [ [[package]] name = "rustls-webpki" -version = "0.103.8" +version = "0.103.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2ffdfa2f5286e2247234e03f680868ac2815974dc39e00ea15adc445d0aafe52" +checksum = "d7df23109aa6c1567d1c575b9952556388da57401e4ace1d15f79eedad0d8f53" dependencies = [ "ring", "rustls-pki-types", @@ -3833,7 +3783,7 @@ dependencies = [ "rustc-demangle", "scala-native-demangle", "srcsrv", - "thiserror 2.0.17", + "thiserror 2.0.18", "uuid", "yoke", "yoke-derive", @@ -3954,24 +3904,13 @@ dependencies = [ "zmij", ] -[[package]] -name = "serde_path_to_error" -version = "0.1.20" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "10a9ff822e371bb5403e391ecd83e182e0e77ba7f6fe0160b795797109d1b457" -dependencies = [ - "itoa", - "serde", - "serde_core", -] - [[package]] name = "serde_spanned" -version = "0.6.9" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3" +checksum = "f8bbf91e5a4d6315eee45e704372590b30e260ee83af6639d64557f51b067776" dependencies = [ - "serde", + "serde_core", ] [[package]] @@ -4064,7 +4003,7 @@ checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa" [[package]] name = "sinktools" version = "0.0.1" -source = "git+https://github.com/hydro-project/hydro.git#17bd0540e496733c64527f9a0ef63b2b0bf47380" +source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" dependencies = [ "futures-util", "pin-project-lite", @@ -4134,7 +4073,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "85cd3e3828fb4dd5ba0e7091777edb6c3db3cd2d6fc10547b29b40f6949a29be" dependencies = [ "memchr", - "thiserror 2.0.17", + "thiserror 2.0.18", ] [[package]] @@ -4174,9 +4113,9 @@ checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" [[package]] name = "stageleft" -version = "0.11.0" +version = "0.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "57d298ebe7d1c345ace8f9aa75de8e80dc11cf3c7263be203b3e1d3686eee073" +checksum = "36eaefb60f9f46e22a155170c369356ce23f7f86f66e262247215a9d38a5b20a" dependencies = [ "ctor 0.4.3", "proc-macro-crate", @@ -4188,9 +4127,9 @@ dependencies = [ [[package]] name = "stageleft_macro" -version = "0.11.0" +version = "0.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b75caa0673619e888064be2c6776d5d776333f07fff4d2c13e76570769f92766" +checksum = "49d0693d2610bb355238fb72ff5ab1ad75523314cca9f5896338f75342715213" dependencies = [ "proc-macro-crate", "proc-macro2", @@ -4201,9 +4140,9 @@ dependencies = [ [[package]] name = "stageleft_tool" -version = "0.11.0" +version = "0.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "62dbaa8c42dbec00aa24188b6a8a568021e70b132fa1944f9c7f035510934f5a" +checksum = "9c0507e668793592e373859d47549ce55b45fff3a475385ea1d9d2f42139a3d3" dependencies = [ "prettyplease", "proc-macro-crate", @@ -4284,7 +4223,7 @@ dependencies = [ "http", "reqwest", "scopeguard", - "thiserror 2.0.17", + "thiserror 2.0.18", "tokio", ] @@ -4329,6 +4268,12 @@ dependencies = [ "syn", ] +[[package]] +name = "target-triple" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "591ef38edfb78ca4771ee32cf494cb8771944bee237a9b91fc9c1424ac4b777b" + [[package]] name = "tempfile" version = "3.24.0" @@ -4362,11 +4307,11 @@ dependencies = [ [[package]] name = "thiserror" -version = "2.0.17" +version = "2.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8" +checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4" dependencies = [ - "thiserror-impl 2.0.17", + "thiserror-impl 2.0.18", ] [[package]] @@ -4382,9 +4327,9 @@ dependencies = [ [[package]] name = "thiserror-impl" -version = "2.0.17" +version = "2.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913" +checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5" dependencies = [ "proc-macro2", "quote", @@ -4402,22 +4347,22 @@ dependencies = [ [[package]] name = "time" -version = "0.3.44" +version = "0.3.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d" +checksum = "f9e442fc33d7fdb45aa9bfeb312c095964abdf596f7567261062b2a7107aaabd" dependencies = [ "deranged", "num-conv", "powerfmt", - "serde", + "serde_core", "time-core", ] [[package]] name = "time-core" -version = "0.1.6" +version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b" +checksum = "8b36ee98fd31ec7426d599183e8fe26932a8dc1fb76ddb6214d05493377d34ca" [[package]] name = "tiny-keccak" @@ -4518,14 +4463,17 @@ dependencies = [ [[package]] name = "toml" -version = "0.8.23" +version = "0.9.11+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362" +checksum = "f3afc9a848309fe1aaffaed6e1546a7a14de1f935dc9d89d32afd9a44bab7c46" dependencies = [ - "serde", + "indexmap", + "serde_core", "serde_spanned", - "toml_datetime 0.6.11", - "toml_edit 0.22.27", + "toml_datetime 0.7.5+spec-1.1.0", + "toml_parser", + "toml_writer", + "winnow", ] [[package]] @@ -4533,9 +4481,6 @@ name = "toml_datetime" version = "0.6.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c" -dependencies = [ - "serde", -] [[package]] name = "toml_datetime" @@ -4553,8 +4498,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a" dependencies = [ "indexmap", - "serde", - "serde_spanned", "toml_datetime 0.6.11", "toml_write", "winnow", @@ -4587,11 +4530,17 @@ version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801" +[[package]] +name = "toml_writer" +version = "1.0.6+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab16f14aed21ee8bfd8ec22513f7287cd4a91aa92e44edfe2c17ddd004e92607" + [[package]] name = "tower" -version = "0.5.2" +version = "0.5.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9" +checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4" dependencies = [ "futures-core", "futures-util", @@ -4726,14 +4675,15 @@ dependencies = [ [[package]] name = "trybuild-internals-api" -version = "1.0.99" +version = "1.0.114" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0bde7ac6ae8a3798bbd277b668363eec49497db8f7beb14070b3eaf09e6884a8" +checksum = "c823ac353d4ef60d9ed955b3294f0dafb0e05180175bc170a4c555f7e0a3333f" dependencies = [ "glob", "serde", "serde_derive", "serde_json", + "target-triple", "termcolor", "toml", ] @@ -4837,7 +4787,7 @@ checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" [[package]] name = "variadics" version = "0.0.10" -source = "git+https://github.com/hydro-project/hydro.git#17bd0540e496733c64527f9a0ef63b2b0bf47380" +source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" dependencies = [ "hashbrown 0.14.5", "hydro_build_utils", @@ -4877,18 +4827,18 @@ checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" [[package]] name = "wasip2" -version = "1.0.1+wasi-0.2.4" +version = "1.0.2+wasi-0.2.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7" +checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5" dependencies = [ "wit-bindgen", ] [[package]] name = "wasm-bindgen" -version = "0.2.106" +version = "0.2.108" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0d759f433fa64a2d763d1340820e46e111a7a5ab75f993d1852d70b03dbb80fd" +checksum = "64024a30ec1e37399cf85a7ffefebdb72205ca1c972291c51512360d90bd8566" dependencies = [ "cfg-if", "once_cell", @@ -4899,11 +4849,12 @@ dependencies = [ [[package]] name = "wasm-bindgen-futures" -version = "0.4.56" +version = "0.4.58" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "836d9622d604feee9e5de25ac10e3ea5f2d65b41eac0d9ce72eb5deae707ce7c" +checksum = "70a6e77fd0ae8029c9ea0063f87c46fde723e7d887703d74ad2616d792e51e6f" dependencies = [ "cfg-if", + "futures-util", "js-sys", "once_cell", "wasm-bindgen", @@ -4912,9 +4863,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro" -version = "0.2.106" +version = "0.2.108" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "48cb0d2638f8baedbc542ed444afc0644a29166f1595371af4fecf8ce1e7eeb3" +checksum = "008b239d9c740232e71bd39e8ef6429d27097518b6b30bdf9086833bd5b6d608" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -4922,9 +4873,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.106" +version = "0.2.108" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cefb59d5cd5f92d9dcf80e4683949f15ca4b511f4ac0a6e14d4e1ac60c6ecd40" +checksum = "5256bae2d58f54820e6490f9839c49780dff84c65aeab9e772f15d5f0e913a55" dependencies = [ "bumpalo", "proc-macro2", @@ -4935,9 +4886,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-shared" -version = "0.2.106" +version = "0.2.108" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cbc538057e648b67f72a982e708d485b2efa771e1ac05fec311f9f63e5800db4" +checksum = "1f01b580c9ac74c8d8f0c0e4afb04eeef2acf145458e52c03845ee9cd23e3d12" dependencies = [ "unicode-ident", ] @@ -4957,9 +4908,9 @@ dependencies = [ [[package]] name = "web-sys" -version = "0.3.83" +version = "0.3.85" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b32828d774c412041098d182a8b38b16ea816958e07cf40eec2bc080ae137ac" +checksum = "312e32e551d92129218ea9a2452120f4aabc03529ef03e4d0d82fb2780608598" dependencies = [ "js-sys", "wasm-bindgen", @@ -5000,6 +4951,17 @@ dependencies = [ "rustls-pki-types", ] +[[package]] +name = "which" +version = "8.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3fabb953106c3c8eea8306e4393700d7657561cb43122571b172bbfb7c7ba1d" +dependencies = [ + "env_home", + "rustix", + "winsafe", +] + [[package]] name = "wholesym" version = "0.8.1" @@ -5021,7 +4983,7 @@ dependencies = [ "samply-symbols", "scopeguard", "symsrv", - "thiserror 2.0.17", + "thiserror 2.0.18", "tokio", "uuid", "yoke", @@ -5422,11 +5384,17 @@ dependencies = [ "memchr", ] +[[package]] +name = "winsafe" +version = "0.0.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d135d17ab770252ad95e9a872d365cf3090e3be864a34ab46f48555993efc904" + [[package]] name = "wit-bindgen" -version = "0.46.0" +version = "0.51.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59" +checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5" [[package]] name = "writeable" @@ -5545,6 +5513,6 @@ checksum = "40990edd51aae2c2b6907af74ffb635029d5788228222c4bb811e9351c0caad3" [[package]] name = "zmij" -version = "1.0.13" +version = "1.0.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac93432f5b761b22864c774aac244fa5c0fd877678a4c37ebf6cf42208f9c9ec" +checksum = "dfcd145825aace48cff44a8844de64bf75feec3080e0aa5cdbde72961ae51a65" diff --git a/Cargo.toml b/Cargo.toml index eb1b5b8..e10b2b7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,11 +13,11 @@ hydro_std = { version = "0.15.0", git = "https://github.com/hydro-project/hydro. hydro_test = { version = "0.0.0", git = "https://github.com/hydro-project/hydro.git" } dfir_lang = { version = "0.15.0", git = "https://github.com/hydro-project/hydro.git" } hydro_build_utils = { version = "0.0.1", git = "https://github.com/hydro-project/hydro.git" } -hydro_deploy = { version = "0.15.0", git = "https://github.com/hydro-project/hydro.git" } +hydro_deploy = { version = "0.15.0", git = "https://github.com/hydro-project/hydro.git", features = ["profile-folding"] } include_mdtests = { version = "0.0.0", git = "https://github.com/hydro-project/hydro.git" } serde = { version = "1.0.197", features = ["derive"] } -stageleft = "0.11.0" -stageleft_tool = "0.11.0" +stageleft = "0.13.0" +stageleft_tool = "0.13.0" tokio = { version = "1.29.0", features = ["full"] } ctor = "0.2" clap = { version = "4.4", features = ["derive"] } diff --git a/hydro_optimize/src/debug.rs b/hydro_optimize/src/debug.rs index bbb7696..617cf98 100644 --- a/hydro_optimize/src/debug.rs +++ b/hydro_optimize/src/debug.rs @@ -21,10 +21,9 @@ fn print_id_node(node: &mut HydroNode, next_stmt_id: &mut usize) { .map(|m| m.op.id) .collect::>>(); println!( - "{} Node {}, Backtrace: {:?}, {:?}, Cardinality: {:?}, CPU Usage: {:?}, Network Recv CPU Usage: {:?}, Inputs: {:?}", + "{} Node {}, {:?}, Cardinality: {:?}, CPU Usage: {:?}, Network Recv CPU Usage: {:?}, Inputs: {:?}", next_stmt_id, node.print_root(), - metadata.op.backtrace.elements(), metadata, metadata.cardinality, metadata.op.cpu_usage, diff --git a/hydro_optimize/src/parse_results.rs b/hydro_optimize/src/parse_results.rs index e63cc2e..f2ae846 100644 --- a/hydro_optimize/src/parse_results.rs +++ b/hydro_optimize/src/parse_results.rs @@ -207,10 +207,11 @@ pub async fn analyze_process_results( op_to_count: &mut HashMap, node_cardinality: &mut UnboundedReceiver, ) -> f64 { - let perf_results = process.tracing_results().unwrap(); + let underlying = process.underlying(); + let perf_results = underlying.tracing_results().unwrap(); // Inject perf usages into metadata - let unidentified_usage = inject_perf(ir, perf_results.folded_data); + let unidentified_usage = inject_perf(ir, perf_results.folded_data.clone()); // Get cardinality data. Allow later values to overwrite earlier ones while let Some(measurement) = node_cardinality.recv().await { @@ -234,7 +235,7 @@ pub async fn analyze_cluster_results( let mut max_usage_cluster_name = String::new(); let mut max_usage_overall = 0f64; let mut op_to_count = HashMap::new(); - + for (id, name, cluster) in nodes.get_all_clusters() { println!("Analyzing cluster {:?}: {}", id, name); diff --git a/hydro_optimize/src/tests/two_pc.rs b/hydro_optimize/src/tests/two_pc.rs index e8139ad..378d6fa 100644 --- a/hydro_optimize/src/tests/two_pc.rs +++ b/hydro_optimize/src/tests/two_pc.rs @@ -1,4 +1,4 @@ -use std::collections::{BTreeMap, HashMap}; +tuse std::collections::{BTreeMap, HashMap}; use hydro_build_utils::insta; use hydro_lang::compile::ir::deep_clone; diff --git a/hydro_optimize_examples/examples/benchmark_paxos.rs b/hydro_optimize_examples/examples/benchmark_paxos.rs index f2bdd50..7835cdc 100644 --- a/hydro_optimize_examples/examples/benchmark_paxos.rs +++ b/hydro_optimize_examples/examples/benchmark_paxos.rs @@ -50,9 +50,9 @@ async fn main() { let i_am_leader_check_timeout_delay_multiplier = 15; // Benchmark parameters - let num_clients = [1, 2]; - let num_clients_per_node = vec![1, 500, 1000, 2000, 3000]; - let run_seconds = 60; + let num_clients = [1, 2, 3, 4, 5]; + let num_clients_per_node = vec![1, 50, 100]; + let run_seconds = 30; let multi_run_metadata = RefCell::new(vec![]); let mut iteration = 0; diff --git a/hydro_optimize_examples/src/lobsters.rs b/hydro_optimize_examples/src/lobsters.rs index 7d1546e..bd48d87 100644 --- a/hydro_optimize_examples/src/lobsters.rs +++ b/hydro_optimize_examples/src/lobsters.rs @@ -6,9 +6,9 @@ use hydro_lang::{ nondet::nondet, prelude::{Process, Stream, Unbounded}, }; +use serde::{Deserialize, Serialize}; use sha2::{Digest, Sha256}; use stageleft::q; -use serde::{Deserialize, Serialize}; use tokio::time::Instant; pub struct Server {} @@ -28,7 +28,7 @@ impl PartialOrd for Story { /// Implementation of Lobsters, roughly based on API calls exposed here: https://lobste.rs/s/cqnzl5/lobste_rs_access_pattern_statistics_for#c_2op8by /// We expose the following APIs: -/// - add_user (takes username, returns api_key, should only approve if user is admin but it's tautological so just approve everyone) +/// - add_user (takes username, returns api_key. Rejects if the user already exists (returns None)) /// - get_users (returns usernames) /// - add_story (takes api_key, title, timestamp, returns story_id) /// - add_comment (takes api_key, story_id, comment, timestamp, returns comment_id) @@ -46,64 +46,71 @@ impl PartialOrd for Story { )] pub fn lobsters<'a, Client>( server: &Process<'a, Server>, - add_user: Stream<(MemberId, String), Process<'a, Server>, Unbounded, NoOrder>, - get_users: Stream, Process<'a, Server>, Unbounded, NoOrder>, - add_story: Stream< - (MemberId, (String, String, Instant)), + add_user: KeyedStream<(MemberId, u32), String, Process<'a, Server>, Unbounded, NoOrder>, + get_users: Stream<(MemberId, u32), Process<'a, Server>, Unbounded, NoOrder>, + add_story: KeyedStream< + (MemberId, u32), + (String, String, Instant), Process<'a, Server>, Unbounded, NoOrder, >, - _add_comment: Stream< - (MemberId, (String, u32, String, Instant)), + _add_comment: KeyedStream< + (MemberId, u32), + (String, u32, String, Instant), Process<'a, Server>, Unbounded, NoOrder, >, - _upvote_story: Stream< - (MemberId, (String, u32)), + _upvote_story: KeyedStream< + (MemberId, u32), + (String, u32), Process<'a, Server>, Unbounded, NoOrder, >, - _upvote_comment: Stream< - (MemberId, (String, u32)), + _upvote_comment: KeyedStream< + (MemberId, u32), + (String, u32), Process<'a, Server>, Unbounded, NoOrder, >, - _get_stories: Stream, Process<'a, Server>, Unbounded, NoOrder>, - _get_comments: Stream, Process<'a, Server>, Unbounded, NoOrder>, - _get_story_comments: Stream<(MemberId, u32), Process<'a, Server>, Unbounded, NoOrder>, + _get_stories: Stream<(MemberId, u32), Process<'a, Server>, Unbounded, NoOrder>, + _get_comments: Stream<(MemberId, u32), Process<'a, Server>, Unbounded, NoOrder>, + _get_story_comments: KeyedStream< + (MemberId, u32), + u32, + Process<'a, Server>, + Unbounded, + NoOrder, + >, +) -> ( + KeyedStream<(MemberId, u32), Option, Process<'a, Server>, Unbounded, NoOrder>, // add_user response ) { let user_auth_tick = server.tick(); let stories_tick = server.tick(); - // Add user - let add_user_with_api_key = add_user.map(q!(|(client_id, username)| { - let api_key = self::generate_api_key(username.clone()); - (client_id, (username, api_key)) - })); - let users_this_tick_with_api_key = add_user_with_api_key.batch( - &user_auth_tick, - nondet!(/** Snapshot current users to approve/deny access */), - ); // Persisted users - let curr_users = users_this_tick_with_api_key - .clone() - .map(q!(|(_client_id, (username, api_key))| (api_key, username))) - .persist(); - let curr_users_hashset = curr_users.clone().fold_commutative_idempotent( - q!(|| HashSet::new()), - q!(|set, (_api_key, username)| { - set.insert(username); - }), - ); + let curr_users = add_user + .map(q!(|(_client_id, username)| ( + username, + self::generate_api_key(username.clone()) + ))) + .into_keyed() + .assume_ordering(nondet!(/** First user wins */)) + .first(); // Send response back to client. Only done after the tick to ensure that once the client gets the response, the user has been added - let _add_user_response = - users_this_tick_with_api_key - .all_ticks() - .map(q!(|(client_id, (_api_key, _username))| (client_id, ()))); + let add_user_response = sliced! { + let new_users = use(add_user_with_api_key, nondet!(/** New users requests this tick */)); + let curr_users = use(curr_users, nondet!(/** Current users this tick */)); + new_users + .map(q!(|(client_id, (username, api_key))| { + (username, (client_id, api_key)) + })) + .into_keyed() + + }; // Get users let _get_users_response = get_users @@ -153,6 +160,8 @@ pub fn lobsters<'a, Client>( } ), ); + + (add_user_response,) } fn generate_api_key(email: String) -> String { @@ -162,4 +171,4 @@ fn generate_api_key(email: String) -> String { hasher.update(secret.as_bytes()); let hash = hasher.finalize(); format!("{:x}", hash) -} \ No newline at end of file +} diff --git a/hydro_optimize_examples/src/lock_server.rs b/hydro_optimize_examples/src/lock_server.rs index b424e89..359f99f 100644 --- a/hydro_optimize_examples/src/lock_server.rs +++ b/hydro_optimize_examples/src/lock_server.rs @@ -11,28 +11,20 @@ pub struct Server {} /// Lock server implementation as described in https://dl.acm.org/doi/pdf/10.1145/3341301.3359651, with the difference being that each server can hold multiple locks. /// * `acquires`: Stream of (virt_client_id, lock_id), requesting a lock from the server. If the server currently holds the lock, it returns (virt_client_id, lock_id, true). Otherwise, it returns (virt_client_id, lock_id, false). /// * `releases`: Stream of (virt_client_id, lock_id), releasing a lock back to the server. Returns (virt_client_id, lock_id). -/// +/// /// Assumptions: /// - No client will send a release message before it knows it has acquired the lock. /// - Clients block on ACKs for outgoing messages; no client has 2 in-flight messages. +/// #[expect(clippy::type_complexity, reason = "internal Lock Server code // TODO")] pub fn lock_server<'a, Client>( server: &Process<'a, Server>, - acquires: KeyedStream< - MemberId, - (u32, u32), - Process<'a, Server>, - Unbounded, - NoOrder, - >, - releases: KeyedStream< - MemberId, - (u32, u32), - Process<'a, Server>, - Unbounded, - NoOrder, - >, -) -> (KeyedStream, (u32, u32, bool), Process<'a, Server>, Unbounded, NoOrder>, KeyedStream, (u32, u32), Process<'a, Server>, Unbounded, NoOrder>) { + acquires: KeyedStream, (u32, u32), Process<'a, Server>, Unbounded, NoOrder>, + releases: KeyedStream, (u32, u32), Process<'a, Server>, Unbounded, NoOrder>, +) -> ( + KeyedStream, (u32, u32, bool), Process<'a, Server>, Unbounded, NoOrder>, + KeyedStream, (u32, u32), Process<'a, Server>, Unbounded, NoOrder>, +) { let server_tick = server.tick(); let keyed_payloads = payloads .entries() @@ -44,47 +36,133 @@ pub fn lock_server<'a, Client>( let batched_payloads = keyed_payloads .assume_ordering(nondet!(/** For each key, the first to acquire the lock wins */)); - let lock_state = batched_payloads + let lock_state = batched_payloads.clone().across_ticks(|stream| { + stream.reduce(q!( + |(curr_client_id, curr_virt_client_id, is_held_by_client), + (client_id, virt_client_id, acquire)| { + if acquire { + // If the lock is currently held by the server, give the client the lock + if !*is_held_by_client { + *curr_client_id = client_id; + *curr_virt_client_id = virt_client_id; + *is_held_by_client = true; + } + } else { + // If the client is releasing the lock and it holds it, give the lock back to the server + if *is_held_by_client + && *curr_virt_client_id == virt_client_id + && *curr_client_id == client_id + { + *is_held_by_client = false; + } + } + } + )) + }); + let results = batched_payloads + .cross_singleton(lock_state) + .all_ticks() + .map(q!(|( + lock_id, + ( + (client_id, virt_client_id, acquire), + (curr_client_id, curr_virt_client_id, is_held_by_client), + ), + )| { + if acquire { + let acquired = is_held_by_client + && curr_client_id == client_id + && curr_virt_client_id == virt_client_id; + (client_id, (virt_client_id, lock_id, acquired)) + } else { + // Releasing always succeeds + (client_id, (virt_client_id, lock_id, true)) + } + })); + results +} + +/// Lock server implementation as described in https://dl.acm.org/doi/pdf/10.1145/3341301.3359651, with the difference being that each server can hold multiple locks. +/// * `acquires`: Stream of (virt_client_id, lock_id), requesting a lock from the server. If the server currently holds the lock, it returns (virt_client_id, lock_id, true). Otherwise, it returns (virt_client_id, lock_id, false). +/// * `releases`: Stream of (virt_client_id, lock_id), releasing a lock back to the server. Returns (virt_client_id, lock_id). +/// +/// Assumptions: +/// - No client will send a release message before it knows it has acquired the lock. +/// - Clients block on ACKs for outgoing messages; no client has 2 in-flight messages. +/// +/// This version iterates through each request in order, as one might on a single-threaded server. +#[expect(clippy::type_complexity, reason = "internal Lock Server code // TODO")] +pub fn assume_order_lock_server<'a, Client>( + server: &Process<'a, Server>, + acquires: KeyedStream, (u32, u32), Process<'a, Server>, Unbounded, NoOrder>, + releases: KeyedStream, (u32, u32), Process<'a, Server>, Unbounded, NoOrder>, +) -> ( + KeyedStream, (u32, u32, bool), Process<'a, Server>, Unbounded, NoOrder>, + KeyedStream, (u32, u32), Process<'a, Server>, Unbounded, NoOrder>, +) { + let server_tick = server.tick(); + let atomic_acquires = acquires .clone() - .across_ticks(|stream| { - stream.reduce(q!( - |(curr_client_id, curr_virt_client_id, is_held_by_client), - (client_id, virt_client_id, acquire)| { - if acquire { - // If the lock is currently held by the server, give the client the lock - if !*is_held_by_client { - *curr_client_id = client_id; - *curr_virt_client_id = virt_client_id; - *is_held_by_client = true; - } - } else { - // If the client is releasing the lock and it holds it, give the lock back to the server - if *is_held_by_client - && *curr_virt_client_id == virt_client_id - && *curr_client_id == client_id + .entries() + .map(q!(|(client_id, (virtual_client_id, lock_id))| ( + lock_id, + (client_id, virtual_client_id, true) + ))) + .atomic(&server_tick); + let atomic_releases = releases + .clone() + .entries() + .map(q!(|(client_id, (virtual_client_id, lock_id))| ( + lock_id, + (client_id, virtual_client_id, false) + ))) + .atomic(&server_tick); + let payloads = atomic_acquires.interleave(atomic_releases).into_keyed(); + + let lock_state = payloads + .assume_ordering(nondet!(/** Process in arrival order */)) + .fold( + q!(|| None), + q!(|curr_holder, (client_id, virtual_client_id, acquire)| { + if acquire { + // If the lock is currently held by the server, give the client the lock + if curr_holder.is_none() { + *curr_holder = Some((client_id.clone(), virtual_client_id.clone())); + } + } else { + // If the client is releasing the lock and it holds it, give the lock back to the server + if let Some((holder_client_id, holder_virtual_client_id)) = curr_holder.as_ref() + { + if *holder_client_id == client_id + && *holder_virtual_client_id == virtual_client_id { - *is_held_by_client = false; + *curr_holder = None; } } } - )) - }); - let results = batched_payloads.cross_singleton(lock_state).all_ticks().map(q!(|( - lock_id, - ( - (client_id, virt_client_id, acquire), - (curr_client_id, curr_virt_client_id, is_held_by_client), - ), - )| { - if acquire { - let acquired = is_held_by_client - && curr_client_id == client_id - && curr_virt_client_id == virt_client_id; - (client_id, (virt_client_id, lock_id, acquired)) - } else { - // Releasing always succeeds - (client_id, (virt_client_id, lock_id, true)) - } - })); - results + }), + ); + + // TODO + let acquire_results = sliced! { + let payloads = use::atomic(payloads, nondet!(/** Payloads at this tick */)); + let locks_snapshot = use::atomic(lock_state, nondet!(/** Snapshot of lock state at this tick */)); + + payloads.clone() + .filter(q!(|(_, (_, _, acquire))| acquire)) + .cross_singleton(locks_snapshot) + }; + + let release_results = payloads + .end_atomic() + .entries() + .filter_map(q!(|(lock_id, (client_id, virtual_client_id, acquire))| { + if !acquire { + Some((client_id, (virtual_client_id, lock_id))) + } else { + None + } + })) + .into_keyed(); + (acquire_results, release_results) } diff --git a/hydro_optimize_examples/src/network_calibrator.rs b/hydro_optimize_examples/src/network_calibrator.rs index 372166a..381a731 100644 --- a/hydro_optimize_examples/src/network_calibrator.rs +++ b/hydro_optimize_examples/src/network_calibrator.rs @@ -1,9 +1,9 @@ use hydro_lang::{ live_collections::stream::NoOrder, nondet::nondet, - prelude::{Cluster, Process, Stream, TCP, Unbounded}, + prelude::{Cluster, KeyedStream, Process, Stream, TCP, Unbounded}, }; -use hydro_std::bench_client::{bench_client, print_bench_results}; +use hydro_std::bench_client::{bench_client, compute_throughput_latency, print_bench_results}; use stageleft::q; @@ -18,9 +18,12 @@ pub fn network_calibrator<'a>( clients: &Cluster<'a, Client>, client_aggregator: &Process<'a, Aggregator>, ) { - let bench_results = bench_client( + let latencies = bench_client( clients, - |_client, payload_request| size_based_workload_generator(message_size, payload_request), + num_clients_per_node, + |_client, ids_and_prev_payloads| { + size_based_workload_generator(message_size, ids_and_prev_payloads) + }, |payloads| { // Server just echoes the payload payloads @@ -28,28 +31,33 @@ pub fn network_calibrator<'a>( .demux(clients, TCP.bincode()) .values() }, - num_clients_per_node, - nondet!(/** bench */), - ); + ).values().map(q!(|(_client_id, latency)| latency)); + let bench_results = compute_throughput_latency(clients, latencies, nondet!(/** bench */)); print_bench_results(bench_results, client_aggregator, clients); } /// Generates an incrementing u32 for each virtual client ID, starting at 0 pub fn size_based_workload_generator<'a, Client>( message_size: usize, - payload_request: Stream<(u32, Option>), Cluster<'a, Client>, Unbounded, NoOrder>, -) -> Stream<(u32, Vec), Cluster<'a, Client>, Unbounded, NoOrder> { - payload_request.map(q!(move |(virtual_id, payload)| { + ids_and_prev_payloads: KeyedStream< + u32, + Option>, + Cluster<'a, Client>, + Unbounded, + NoOrder, + >, +) -> KeyedStream, Cluster<'a, Client>, Unbounded, NoOrder> { + ids_and_prev_payloads.map(q!(move |payload| { if let Some(mut payload) = payload { if let Some(last) = payload.last_mut() { *last += 1; - return (virtual_id, payload); + return payload; } } // Temp fix for macro stuff that isn't supported by stageleft I guess let msg_size = message_size; - (virtual_id, vec![0; msg_size]) + vec![0; msg_size] })) } diff --git a/hydro_optimize_examples/src/simple_kv_bench.rs b/hydro_optimize_examples/src/simple_kv_bench.rs index eee9ccd..3e7ba65 100644 --- a/hydro_optimize_examples/src/simple_kv_bench.rs +++ b/hydro_optimize_examples/src/simple_kv_bench.rs @@ -1,13 +1,11 @@ -use std::time::SystemTime; - use hydro_lang::{ location::Location, nondet::nondet, prelude::{Cluster, Process, TCP}, }; -use hydro_std::bench_client::{bench_client, print_bench_results}; +use hydro_std::bench_client::{bench_client, compute_throughput_latency, print_bench_results}; -use hydro_test::cluster::paxos_bench::inc_u32_workload_generator; +use hydro_test::cluster::paxos_bench::inc_i32_workload_generator; use stageleft::q; pub struct Kv; @@ -20,59 +18,37 @@ pub fn simple_kv_bench<'a>( clients: &Cluster<'a, Client>, client_aggregator: &Process<'a, Aggregator>, ) { - // Set up client that auto-generates requests with virtual IDs - let (c_received_payloads_complete, c_received_payloads) = clients.forward_ref(); - let c_new_payload_ids = bench_client(clients, num_clients_per_node, c_received_payloads); - - // Attach payloads to requests - let c_payloads = c_new_payload_ids.map(q!(move |payload| { - let value = if let Some((counter, _time)) = payload { - counter + 1 - } else { - 0 - }; - // Record current time for latency - (value, SystemTime::now()) - })); - - // Protocol - let k_tick = kv.tick(); - // Use atomic to prevent outputting to the client before values are inserted to the KV store - let k_payloads = c_payloads.send(kv, TCP.bincode()).atomic(&k_tick); - - let for_each_tick = kv.tick(); - // Insert each payload into the KV store - k_payloads - .clone() - .assume_ordering(nondet!(/** Last writer wins per key. */)) - // Persist state across ticks - .reduce(q!(|prev, new| { - *prev = new; - })) - .end_atomic() - .snapshot( - &for_each_tick, - nondet!(/** for_each does nothing, just need to end on a HydroRoot */), - ) - .entries() - .all_ticks() - .assume_ordering(nondet!(/** for_each does nothing, just need to end on a HydroRoot */)) - .assume_retries(nondet!(/** for_each does nothing, just need to end on a HydroRoot */)) - .for_each(q!(|_| {})); // Do nothing, just need to end on a HydroRoot - - // Send committed requests back to the original client - let completed_payloads = k_payloads - .end_atomic() - .demux(clients, TCP.bincode()) - .into_keyed(); - - // Send committed requests back to the original client - c_received_payloads_complete.complete(completed_payloads.clone()); - - // Create throughput/latency graphs - let latencies = completed_payloads.values().map(q!(move |(_counter, time)| { - SystemTime::now().duration_since(time).unwrap() - })); + let latencies = bench_client(clients, num_clients_per_node, inc_i32_workload_generator, |input| { + let k_tick = kv.tick(); + // Use atomic to prevent outputting to the client before values are inserted to the KV store + let k_payloads = input.send(kv, TCP.bincode()).atomic(&k_tick); + + let for_each_tick = kv.tick(); + // Insert each payload into the KV store + k_payloads + .clone() + .assume_ordering(nondet!(/** Last writer wins per key. */)) + // Persist state across ticks + .reduce(q!(|prev, new| { + *prev = new; + })) + .end_atomic() + .snapshot( + &for_each_tick, + nondet!(/** for_each does nothing, just need to end on a HydroRoot */), + ) + .entries() + .all_ticks() + .assume_ordering(nondet!(/** for_each does nothing, just need to end on a HydroRoot */)) + .assume_retries(nondet!(/** for_each does nothing, just need to end on a HydroRoot */)) + .for_each(q!(|_| {})); // Do nothing, just need to end on a HydroRoot + + // Send committed requests back to the original client + k_payloads + .end_atomic() + .demux(clients, TCP.bincode()) + }).values().map(q!(|(_value, latency)| latency)); + let bench_results = compute_throughput_latency(clients, latencies, nondet!(/** bench */)); print_bench_results(bench_results, client_aggregator, clients); } From 6aa2f57b2228ec85a0c3d3fcf857cfa06460a835 Mon Sep 17 00:00:00 2001 From: David Chu Date: Wed, 28 Jan 2026 00:36:46 +0000 Subject: [PATCH 15/35] More merging main :/ --- Cargo.lock | 90 +- hydro_optimize/src/decouple_analysis.rs | 10 +- hydro_optimize/src/decoupler.rs | 23 +- hydro_optimize/src/parse_results.rs | 8 +- hydro_optimize/src/partition_node_analysis.rs | 36 +- hydro_optimize/src/partition_syn_analysis.rs | 44 +- hydro_optimize/src/partitioner.rs | 42 +- hydro_optimize/src/repair.rs | 6 +- hydro_optimize/src/rewrites.rs | 54 +- ...pler__tests__decouple_after_source_ir.snap | 48 +- ...r__tests__move_source_decouple_map_ir.snap | 48 +- hydro_optimize/src/tests/mod.rs | 10 +- ...imize__tests__decoupled_compute_pi_ir.snap | 58 +- ..._tests__partitioned_simple_cluster_ir.snap | 34 +- ..._two_pc__two_pc_partition_coordinator.snap | 2342 ++++++++--------- ..._two_pc__two_pc_partition_participant.snap | 2306 ++++++++-------- hydro_optimize/src/tests/two_pc.rs | 12 +- 17 files changed, 2580 insertions(+), 2591 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 255f239..1e65e2a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -657,9 +657,9 @@ dependencies = [ [[package]] name = "cc" -version = "1.2.53" +version = "1.2.54" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "755d2fce177175ffca841e9a06afdb2c4ab0f593d53b4dee48147dfaade85932" +checksum = "6354c81bbfd62d9cfa9cb3c773c2b7b2a3a482d569de977fd0e961f6e7c00583" dependencies = [ "find-msvc-tools", "shlex", @@ -739,9 +739,9 @@ dependencies = [ [[package]] name = "clap" -version = "4.5.54" +version = "4.5.55" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c6e6ff9dcd79cff5cd969a17a545d79e84ab086e444102a591e288a8aa3ce394" +checksum = "3e34525d5bbbd55da2bb745d34b36121baac88d07619a9a09cfcf4a6c0832785" dependencies = [ "clap_builder", "clap_derive", @@ -749,9 +749,9 @@ dependencies = [ [[package]] name = "clap_builder" -version = "4.5.54" +version = "4.5.55" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fa42cf4d2b7a41bc8f663a7cab4031ebafa1bf3875705bfaf8466dc60ab52c00" +checksum = "59a20016a20a3da95bef50ec7238dbd09baeef4311dcdd38ec15aba69812fb61" dependencies = [ "anstream", "anstyle", @@ -761,9 +761,9 @@ dependencies = [ [[package]] name = "clap_derive" -version = "4.5.49" +version = "4.5.55" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2a0b5487afeab2deb2ff4e03a807ad1a03ac532ff5a2cee5d86884440c7f7671" +checksum = "a92793da1a46a5f2a02a6f4c46c6496b28c43638adea8306fcb0caa1634f24e5" dependencies = [ "heck", "proc-macro2", @@ -895,7 +895,7 @@ dependencies = [ [[package]] name = "copy_span" version = "0.1.0" -source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" +source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" dependencies = [ "proc-macro2", "syn", @@ -1114,7 +1114,7 @@ dependencies = [ [[package]] name = "dfir_lang" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" +source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" dependencies = [ "auto_impl", "documented", @@ -1159,7 +1159,7 @@ dependencies = [ "libc", "option-ext", "redox_users", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -1780,7 +1780,7 @@ checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" [[package]] name = "hydro_build_utils" version = "0.0.1" -source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" +source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" dependencies = [ "insta", "rustc_version", @@ -1789,7 +1789,7 @@ dependencies = [ [[package]] name = "hydro_deploy" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" +source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" dependencies = [ "anyhow", "append-only-vec", @@ -1825,7 +1825,7 @@ dependencies = [ [[package]] name = "hydro_deploy_integration" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" +source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" dependencies = [ "async-recursion", "async-trait", @@ -1843,7 +1843,7 @@ dependencies = [ [[package]] name = "hydro_lang" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" +source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" dependencies = [ "auto_impl", "backtrace", @@ -1934,7 +1934,7 @@ dependencies = [ [[package]] name = "hydro_std" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" +source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" dependencies = [ "hdrhistogram", "hydro_lang", @@ -1946,7 +1946,7 @@ dependencies = [ [[package]] name = "hydro_test" version = "0.0.0" -source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" +source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" dependencies = [ "bytes", "colored", @@ -2154,7 +2154,7 @@ dependencies = [ [[package]] name = "include_mdtests" version = "0.0.0" -source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" +source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" dependencies = [ "glob", "proc-macro2", @@ -2285,7 +2285,7 @@ checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46" dependencies = [ "hermit-abi", "libc", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -2377,9 +2377,9 @@ dependencies = [ [[package]] name = "libm" -version = "0.2.15" +version = "0.2.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de" +checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981" [[package]] name = "libredox" @@ -2644,9 +2644,9 @@ dependencies = [ [[package]] name = "num-conv" -version = "0.1.0" +version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9" +checksum = "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050" [[package]] name = "num-format" @@ -3217,7 +3217,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d" dependencies = [ "anyhow", - "itertools 0.13.0", + "itertools 0.14.0", "proc-macro2", "quote", "syn", @@ -3284,14 +3284,14 @@ dependencies = [ "once_cell", "socket2", "tracing", - "windows-sys 0.59.0", + "windows-sys 0.60.2", ] [[package]] name = "quote" -version = "1.0.43" +version = "1.0.44" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dc74d9a594b72ae6656596548f56f667211f8a97b3d4c3d467150794690dc40a" +checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4" dependencies = [ "proc-macro2", ] @@ -4003,7 +4003,7 @@ checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa" [[package]] name = "sinktools" version = "0.0.1" -source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" +source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" dependencies = [ "futures-util", "pin-project-lite", @@ -4014,9 +4014,9 @@ dependencies = [ [[package]] name = "siphasher" -version = "1.0.1" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d" +checksum = "b2aa850e253778c88a04c3d7323b043aeda9d3e30d5971937c1855769763678e" [[package]] name = "slab" @@ -4042,9 +4042,9 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" [[package]] name = "socket2" -version = "0.6.1" +version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "17129e116933cf371d018bb80ae557e889637989d8638274fb25622827b03881" +checksum = "86f4aa3ad99f2088c990dfa82d367e19cb29268ed67c574d10d0a4bfe71f07e0" dependencies = [ "libc", "windows-sys 0.60.2", @@ -4347,9 +4347,9 @@ dependencies = [ [[package]] name = "time" -version = "0.3.45" +version = "0.3.46" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f9e442fc33d7fdb45aa9bfeb312c095964abdf596f7567261062b2a7107aaabd" +checksum = "9da98b7d9b7dad93488a84b8248efc35352b0b2657397d4167e7ad67e5d535e5" dependencies = [ "deranged", "num-conv", @@ -4360,9 +4360,9 @@ dependencies = [ [[package]] name = "time-core" -version = "0.1.7" +version = "0.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b36ee98fd31ec7426d599183e8fe26932a8dc1fb76ddb6214d05493377d34ca" +checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca" [[package]] name = "tiny-keccak" @@ -4770,9 +4770,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" [[package]] name = "uuid" -version = "1.19.0" +version = "1.20.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2e054861b4bd027cd373e18e8d8d8e6548085000e41290d95ce0c373a654b4a" +checksum = "ee48d38b119b0cd71fe4141b30f5ba9c7c5d9f4e7a3a8b4a674e4b6ef789976f" dependencies = [ "js-sys", "wasm-bindgen", @@ -4787,7 +4787,7 @@ checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" [[package]] name = "variadics" version = "0.0.10" -source = "git+https://github.com/hydro-project/hydro.git#2f38e7eddf0363f818aa4b204c7bf549c317428a" +source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" dependencies = [ "hashbrown 0.14.5", "hydro_build_utils", @@ -5427,18 +5427,18 @@ dependencies = [ [[package]] name = "zerocopy" -version = "0.8.33" +version = "0.8.34" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "668f5168d10b9ee831de31933dc111a459c97ec93225beb307aed970d1372dfd" +checksum = "71ddd76bcebeed25db614f82bf31a9f4222d3fbba300e6fb6c00afa26cbd4d9d" dependencies = [ "zerocopy-derive", ] [[package]] name = "zerocopy-derive" -version = "0.8.33" +version = "0.8.34" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2c7962b26b0a8685668b671ee4b54d007a67d4eaf05fda79ac0ecf41e32270f1" +checksum = "d8187381b52e32220d50b255276aa16a084ec0a9017a0ca2152a1f55c539758d" dependencies = [ "proc-macro2", "quote", @@ -5513,6 +5513,6 @@ checksum = "40990edd51aae2c2b6907af74ffb635029d5788228222c4bb811e9351c0caad3" [[package]] name = "zmij" -version = "1.0.16" +version = "1.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dfcd145825aace48cff44a8844de64bf75feec3080e0aa5cdbde72961ae51a65" +checksum = "02aae0f83f69aafc94776e879363e9771d7ecbffe2c7fbb6c14c5e00dfe88439" diff --git a/hydro_optimize/src/decouple_analysis.rs b/hydro_optimize/src/decouple_analysis.rs index c93142c..eeea002 100644 --- a/hydro_optimize/src/decouple_analysis.rs +++ b/hydro_optimize/src/decouple_analysis.rs @@ -90,7 +90,7 @@ fn add_tick_constraint( .. } = &mut *model_metadata.borrow_mut(); - if let LocationId::Tick(tick_id, _) = metadata.location_kind { + if let LocationId::Tick(tick_id, _) = metadata.location_id { // Set each input = to the last input let mut inputs = op_id_to_inputs .get(&metadata.op.id.unwrap()) @@ -291,7 +291,7 @@ fn decouple_analysis_root( model_metadata: &RefCell, ) { // Ignore nodes that are not in the cluster to decouple - if model_metadata.borrow().cluster_to_decouple != *root.input_metadata().location_kind.root() { + if model_metadata.borrow().cluster_to_decouple != *root.input_metadata().location_id.root() { return; } @@ -306,7 +306,7 @@ fn decouple_analysis_node( ) { let network_type = get_network_type( node, - model_metadata.borrow().cluster_to_decouple.root().raw_id(), + &model_metadata.borrow().cluster_to_decouple.root().key(), ); if let HydroNode::Network { .. } = node { // If this is a network and we're not involved, ignore @@ -317,7 +317,7 @@ fn decouple_analysis_node( .borrow_mut() .network_ids .insert(*op_id, network_type.clone().unwrap()); - } else if model_metadata.borrow().cluster_to_decouple != *node.metadata().location_kind.root() { + } else if model_metadata.borrow().cluster_to_decouple != *node.metadata().location_id.root() { // If it's not a network and the operator isn't on the cluster, ignore return; } @@ -402,7 +402,7 @@ pub(crate) fn decouple_analysis( network_ids: HashMap::new(), }); let op_id_to_inputs = - op_id_to_inputs(ir, Some(cluster_to_decouple), cycle_source_to_sink_input); + op_id_to_inputs(ir, Some(&cluster_to_decouple.key()), cycle_source_to_sink_input); traverse_dfir::( ir, diff --git a/hydro_optimize/src/decoupler.rs b/hydro_optimize/src/decoupler.rs index 9262972..9be87e2 100644 --- a/hydro_optimize/src/decoupler.rs +++ b/hydro_optimize/src/decoupler.rs @@ -31,7 +31,7 @@ pub struct Decoupler { fn add_network(node: &mut HydroNode, new_location: &LocationId) { let metadata = node.metadata().clone(); - let parent_id = metadata.location_kind.root().raw_id(); + let parent_id = metadata.location_id.root().key(); let node_content = std::mem::replace(node, HydroNode::Placeholder); // Map from b to (MemberId, b), where MemberId is the id of the decoupled (or original) node we're sending to @@ -52,7 +52,7 @@ fn add_network(node: &mut HydroNode, new_location: &LocationId) { f: f.into(), input: Box::new(node_content), metadata: HydroIrMetadata { - location_kind: metadata.location_kind.root().clone(), // Remove any ticks + location_id: metadata.location_id.root().clone(), // Remove any ticks collection_kind: new_collection_kind.clone(), cardinality: None, tag: None, @@ -68,6 +68,7 @@ fn add_network(node: &mut HydroNode, new_location: &LocationId) { // Set up the network node let output_debug_type = collection_kind_to_debug_type(&original_collection_kind); let network_node = HydroNode::Network { + name: None, serialize_fn: Some(serialize_bincode_with_type(true, &output_debug_type)).map(|e| e.into()), instantiate_fn: DebugInstantiate::Building, deserialize_fn: Some(deserialize_bincode_with_type( @@ -77,7 +78,7 @@ fn add_network(node: &mut HydroNode, new_location: &LocationId) { .map(|e| e.into()), input: Box::new(mapped_node), metadata: HydroIrMetadata { - location_kind: new_location.clone(), + location_id: new_location.clone(), collection_kind: new_collection_kind, cardinality: None, tag: None, @@ -96,7 +97,7 @@ fn add_network(node: &mut HydroNode, new_location: &LocationId) { f: f.into(), input: Box::new(network_node), metadata: HydroIrMetadata { - location_kind: new_location.clone(), + location_id: new_location.clone(), collection_kind: original_collection_kind, cardinality: None, tag: None, @@ -157,12 +158,12 @@ fn decouple_node( | HydroNode::Network { metadata, .. } => { println!( "Changing source/network destination from {:?} to location {:?}, id: {}", - metadata.location_kind, + metadata.location_id, decoupler.decoupled_location.clone(), next_stmt_id ); metadata - .location_kind + .location_id .swap_root(decoupler.decoupled_location.clone()); } _ => { @@ -226,7 +227,7 @@ fn fix_cluster_self_id_root(root: &mut HydroRoot, mut locations: ClusterSelfIdRe decoupled_cluster_id, .. } = locations - && root.input_metadata().location_kind.root().raw_id() == decoupled_cluster_id + && root.input_metadata().location_id.root().key() == decoupled_cluster_id { root.visit_debug_expr(|expr| { locations.visit_expr_mut(&mut expr.0); @@ -239,7 +240,7 @@ fn fix_cluster_self_id_node(node: &mut HydroNode, mut locations: ClusterSelfIdRe decoupled_cluster_id, .. } = locations - && node.metadata().location_kind.root().raw_id() == decoupled_cluster_id + && node.metadata().location_id.root().key() == decoupled_cluster_id { node.visit_debug_expr(|expr| { locations.visit_expr_mut(&mut expr.0); @@ -279,8 +280,8 @@ pub fn decouple( inject_location(ir, &cycle_source_to_sink_input); // Fix CLUSTER_SELF_ID for the decoupled node let locations = ClusterSelfIdReplace::Decouple { - orig_cluster_id: decoupler.orig_location.raw_id(), - decoupled_cluster_id: decoupler.decoupled_location.raw_id(), + orig_cluster_id: decoupler.orig_location.key(), + decoupled_cluster_id: decoupler.decoupled_location.key(), }; transform_bottom_up( ir, @@ -323,7 +324,7 @@ mod tests { Cluster<'a, ()>, BuiltFlow<'a>, ) { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let send_cluster = builder.cluster::<()>(); let recv_cluster = builder.cluster::<()>(); let decoupled_cluster = builder.cluster::<()>(); diff --git a/hydro_optimize/src/parse_results.rs b/hydro_optimize/src/parse_results.rs index f2ae846..52d9a7d 100644 --- a/hydro_optimize/src/parse_results.rs +++ b/hydro_optimize/src/parse_results.rs @@ -307,8 +307,8 @@ pub fn analyze_send_recv_overheads(ir: &mut [HydroRoot], run_metadata: &mut RunM input, metadata, .. } = node { - let sender = input.metadata().location_kind.root(); - let receiver = metadata.location_kind.root(); + let sender = input.metadata().location_id.root(); + let receiver = metadata.location_id.root(); // Use cardinality from the network's input, not the network itself. // Reason: Cardinality is measured at ONE recipient, but the sender may be sending to MANY machines. @@ -421,7 +421,7 @@ fn record_metadata_root(root: &mut HydroRoot, run_metadata: &mut RunMetadata) { let input = root.input_metadata(); run_metadata .op_id_to_location - .insert(id, input.location_kind.root().clone()); + .insert(id, input.location_id.root().clone()); if let Some(cardinality) = input.cardinality { run_metadata.op_id_to_cardinality.insert(id, cardinality); } @@ -434,7 +434,7 @@ fn record_metadata_node(node: &mut HydroNode, run_metadata: &mut RunMetadata) { let metadata = node.metadata(); run_metadata .op_id_to_location - .insert(id, metadata.location_kind.root().clone()); + .insert(id, metadata.location_id.root().clone()); if let Some(cardinality) = metadata.cardinality { run_metadata.op_id_to_cardinality.insert(id, cardinality); } diff --git a/hydro_optimize/src/partition_node_analysis.rs b/hydro_optimize/src/partition_node_analysis.rs index 4ddfa02..539576e 100644 --- a/hydro_optimize/src/partition_node_analysis.rs +++ b/hydro_optimize/src/partition_node_analysis.rs @@ -35,7 +35,7 @@ fn all_inputs(ir: &mut [HydroRoot], location: &LocationId) -> Vec { traverse_dfir::( ir, |_, _| {}, - |node, next_stmt_id| match get_network_type(node, location.root().raw_id()) { + |node, next_stmt_id| match get_network_type(node, &location.root().key()) { Some(NetworkType::Recv) | Some(NetworkType::SendRecv) => { inputs.push(*next_stmt_id); } @@ -87,7 +87,7 @@ fn input_dependency_analysis_node( metadata: &mut InputDependencyMetadata, ) { // Filter unrelated nodes - if metadata.location != *node.metadata().location_kind.root() { + if metadata.location != *node.metadata().location_id.root() { return; } @@ -606,7 +606,7 @@ pub fn partitioning_analysis( Vec>, BTreeMap, )> { - let op_id_to_parents = op_id_to_inputs(ir, Some(location), cycle_source_to_sink_input); + let op_id_to_parents = op_id_to_inputs(ir, Some(&location.key()), cycle_source_to_sink_input); let dependency_metadata = input_dependency_analysis(ir, location, op_id_to_parents); let mut possible_partitionings = BTreeMap::new(); @@ -793,7 +793,7 @@ mod tests { #[test] fn test_map_partitionable() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster1 = builder.cluster::<()>(); let cluster2 = builder.cluster::<()>(); cluster1 @@ -812,7 +812,7 @@ mod tests { #[test] fn test_map_complex_partitionable() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster1 = builder.cluster::<()>(); let cluster2 = builder.cluster::<()>(); cluster1 @@ -832,7 +832,7 @@ mod tests { #[test] fn test_filter_map_partitionable() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster1 = builder.cluster::<()>(); let cluster2 = builder.cluster::<()>(); cluster1 @@ -851,7 +851,7 @@ mod tests { #[test] fn test_filter_map_remove_none_partitionable() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster1 = builder.cluster::<()>(); let cluster2 = builder.cluster::<()>(); cluster1 @@ -878,7 +878,7 @@ mod tests { #[test] fn test_chain_partitionable() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster1 = builder.cluster::<()>(); let cluster2 = builder.cluster::<()>(); let input = cluster1 @@ -903,7 +903,7 @@ mod tests { #[test] fn test_cross_product_partitionable() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster1 = builder.cluster::<()>(); let cluster2 = builder.cluster::<()>(); let input = cluster1 @@ -928,7 +928,7 @@ mod tests { #[test] fn test_join_partitionable() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster1 = builder.cluster::<()>(); let cluster2 = builder.cluster::<()>(); let input = cluster1 @@ -954,7 +954,7 @@ mod tests { #[test] fn test_enumerate_partitionable() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster1 = builder.cluster::<()>(); let cluster2 = builder.cluster::<()>(); cluster1 @@ -972,7 +972,7 @@ mod tests { #[test] fn test_reduce_keyed_partitionable() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster1 = builder.cluster::<()>(); let cluster2 = builder.cluster::<()>(); cluster1 @@ -999,7 +999,7 @@ mod tests { #[test] fn test_reduce_partitionable() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster1 = builder.cluster::<()>(); let cluster2 = builder.cluster::<()>(); cluster1 @@ -1024,7 +1024,7 @@ mod tests { #[test] fn test_cycle_partitionable() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster1 = builder.cluster::<()>(); let cluster2 = builder.cluster::<()>(); let input = cluster1 @@ -1055,7 +1055,7 @@ mod tests { #[test] fn test_nested_cycle_partitionable() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster1 = builder.cluster::<()>(); let cluster2 = builder.cluster::<()>(); let input = cluster1 @@ -1090,7 +1090,7 @@ mod tests { #[test] fn test_source_iter_partitionable() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster1 = builder.cluster::<()>(); let cluster2 = builder.cluster::<()>(); let input = cluster1 @@ -1115,7 +1115,7 @@ mod tests { #[test] fn test_multiple_inputs_partitionable() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster1 = builder.cluster::<()>(); let cluster2 = builder.cluster::<()>(); let input1 = cluster1 @@ -1158,7 +1158,7 @@ mod tests { #[test] fn test_difference_partitionable() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster1 = builder.cluster::<()>(); let cluster2 = builder.cluster::<()>(); let input1 = cluster1 diff --git a/hydro_optimize/src/partition_syn_analysis.rs b/hydro_optimize/src/partition_syn_analysis.rs index ad6a869..ccad20c 100644 --- a/hydro_optimize/src/partition_syn_analysis.rs +++ b/hydro_optimize/src/partition_syn_analysis.rs @@ -860,7 +860,7 @@ mod tests { #[test] fn test_tuple_input_assignment() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([(1, 2, (3, (4,)), 5)])) @@ -873,7 +873,7 @@ mod tests { #[test] fn test_tuple_input_implicit_nesting() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([(1, 2, (3, (4,)), 5)])) @@ -886,7 +886,7 @@ mod tests { #[test] fn test_tuple_assignment() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([(1, 2, (3, (4,)), 5)])) @@ -902,7 +902,7 @@ mod tests { #[test] fn test_tuple_creation() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([(1, 2, (3, (4,)), 5)])) @@ -918,7 +918,7 @@ mod tests { #[test] fn test_tuple_output_implicit_nesting() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([(1, 2, (3, (4,)), 5)])) @@ -934,7 +934,7 @@ mod tests { #[test] fn test_tuple_input_output_implicit_nesting() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([(1, 2, (3, (4,)), 5)])) @@ -950,7 +950,7 @@ mod tests { #[test] fn test_tuple_no_block() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([(1, 2, (3, (4,)), 5)])) @@ -963,7 +963,7 @@ mod tests { #[test] fn test_if_shared_intersection() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([(1, 2, (3, (4,)), 5)])) @@ -980,7 +980,7 @@ mod tests { #[test] fn test_if_conflicting_intersection() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([(1, 2, (3, (4,)), 5)])) @@ -996,7 +996,7 @@ mod tests { #[test] fn test_if_implicit_expansion() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([(1, 2, (3, (4,)), 5)])) @@ -1011,7 +1011,7 @@ mod tests { #[test] fn test_if_let() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([(1, 2, (3, (4,)), 5)])) @@ -1036,7 +1036,7 @@ mod tests { #[test] fn test_else_if() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([(1, 2, (3, (4,)), 5)])) @@ -1064,7 +1064,7 @@ mod tests { #[test] fn test_if_option() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([(1, 2, (3, (4,)), 5)])) @@ -1077,7 +1077,7 @@ mod tests { #[test] fn test_match() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([(1, 2, (3, (4,)), 5)])) @@ -1099,7 +1099,7 @@ mod tests { #[test] fn test_match_assign() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([(1, 2, (3, (4,)), 5)])) @@ -1120,7 +1120,7 @@ mod tests { #[test] fn test_block() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([(1, 2, (3, (4,)), 5)])) @@ -1140,7 +1140,7 @@ mod tests { #[test] fn test_nested_block() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([(1, 2, (3, (4,)), 5)])) @@ -1163,7 +1163,7 @@ mod tests { #[test] fn test_block_shadowing() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([(1, 2, (3, (4,)), 5)])) @@ -1186,7 +1186,7 @@ mod tests { #[test] fn test_full_assignment() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([(1, 2, (3, (4,)), 5)])) @@ -1243,7 +1243,7 @@ mod tests { #[test] fn test_nested_struct() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([TestStruct { @@ -1275,7 +1275,7 @@ mod tests { #[test] fn test_nested_struct_declaration() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([TestStruct { @@ -1305,7 +1305,7 @@ mod tests { #[test] fn test_struct_implicit_field() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let cluster = builder.cluster::<()>(); cluster .source_iter(q!([TestStruct { diff --git a/hydro_optimize/src/partitioner.rs b/hydro_optimize/src/partitioner.rs index 5afd3fd..96d3ee7 100644 --- a/hydro_optimize/src/partitioner.rs +++ b/hydro_optimize/src/partitioner.rs @@ -3,6 +3,7 @@ use std::collections::HashMap; use hydro_lang::compile::ir::{HydroNode, HydroRoot, traverse_dfir}; use hydro_lang::deploy::HydroDeploy; +use hydro_lang::location::LocationKey; use hydro_lang::location::dynamic::LocationId; use serde::{Deserialize, Serialize}; use syn::visit_mut::{self, VisitMut}; @@ -19,14 +20,14 @@ use crate::rewrites::{ pub struct Partitioner { pub nodes_to_partition: HashMap, /* ID of node right before a Network -> what to partition on */ pub num_partitions: usize, - pub location_id: usize, - pub new_cluster_id: Option, /* If we're partitioning a process, then a new cluster will be created and we'll need to substitute the old ID with this one */ + pub location_id: LocationKey, + pub new_cluster_id: Option, /* If we're partitioning a process, then a new cluster will be created and we'll need to substitute the old ID with this one */ } /// Don't expose partition members to the cluster pub struct ClusterMembersReplace { pub num_partitions: usize, - pub location_id: usize, + pub location_id: LocationKey, pub op_id: usize, } @@ -71,20 +72,20 @@ fn replace_membership_info(node: &mut HydroNode, partitioner: &Partitioner, op_i num_partitions, location_id, .. - } = *partitioner; + } = partitioner; node.visit_debug_expr(|expr| { let mut visitor = ClusterMembersReplace { - num_partitions, - location_id, + num_partitions: *num_partitions, + location_id: location_id.clone(), op_id, }; visitor.visit_expr_mut(&mut expr.0); }); node.visit_debug_expr(|expr| { let mut visitor = ClusterSelfIdReplace::Partition { - num_partitions, - partitioned_cluster_id: location_id, + num_partitions: *num_partitions, + partitioned_cluster_id: location_id.clone(), op_id, }; visitor.visit_expr_mut(&mut expr.0); @@ -184,7 +185,7 @@ fn replace_receiver_src_id(node: &mut HydroNode, partitioner: &Partitioner, op_i if let HydroNode::Network { input, metadata, .. } = node - && input.metadata().location_kind.root().raw_id() == *location_id + && input.metadata().location_id.root().key() == *location_id { println!( "Rewriting network on op {} so the sender's ID is mapped from the partition to the original sender", @@ -211,7 +212,7 @@ fn replace_receiver_src_id(node: &mut HydroNode, partitioner: &Partitioner, op_i fn replace_network_serialization(node: &mut HydroNode, partitioner: &Partitioner, op_id: usize) { let Partitioner { new_cluster_id, .. } = partitioner; - if let Some(network_type) = get_network_type(node, new_cluster_id.unwrap()) { + if let Some(network_type) = get_network_type(node, new_cluster_id.as_ref().unwrap()) { let HydroNode::Network { serialize_fn, deserialize_fn, @@ -256,16 +257,6 @@ fn replace_network_serialization(node: &mut HydroNode, partitioner: &Partitioner } } -fn replace_process_location_id( - location: &mut LocationId, - process_location: usize, - cluster_location: usize, -) { - if location.root().raw_id() == process_location { - location.swap_root(LocationId::Cluster(cluster_location)); - } -} - /// If we're partitioning a process into a cluster, we need to replace references to its location fn replace_process_node_location(node: &mut HydroNode, partitioner: &Partitioner) { let Partitioner { @@ -276,11 +267,10 @@ fn replace_process_node_location(node: &mut HydroNode, partitioner: &Partitioner if let Some(new_id) = new_cluster_id { // Change any HydroNodes with a location field - replace_process_location_id( - &mut node.metadata_mut().location_kind, - *location_id, - *new_id, - ); + let location = &mut node.metadata_mut().location_id; + if location.root().key() == *location_id { + location.swap_root(LocationId::Cluster(*new_id)); + } } } @@ -288,7 +278,7 @@ fn replace_process_node_location(node: &mut HydroNode, partitioner: &Partitioner fn remove_sender_id_from_receiver(node: &mut HydroNode, partitioner: &Partitioner, op_id: usize) { let Partitioner { new_cluster_id, .. } = partitioner; - let network_type = get_network_type(node, new_cluster_id.unwrap()); + let network_type = get_network_type(node, new_cluster_id.as_ref().unwrap()); match network_type { Some(NetworkType::Send) | Some(NetworkType::SendRecv) => { println!("Removing sender ID from receiver for op {}", op_id); diff --git a/hydro_optimize/src/repair.rs b/hydro_optimize/src/repair.rs index 857e35f..5894437 100644 --- a/hydro_optimize/src/repair.rs +++ b/hydro_optimize/src/repair.rs @@ -103,7 +103,7 @@ fn inject_location_node( | HydroNode::ExternalInput { metadata, .. } | HydroNode::Network { metadata, .. } => { // Get location sources from the nodes must have it be correct: Source and Network - id_to_location.insert(op_id, metadata.location_kind.clone()); + id_to_location.insert(op_id, metadata.location_id.clone()); return false; } HydroNode::Tee { inner, .. } => { @@ -124,8 +124,8 @@ fn inject_location_node( for input in inputs { let location = id_to_location.get(&input).cloned(); if let Some(location) = location { - metadata.location_kind.swap_root(location.root().clone()); - id_to_location.insert(op_id, metadata.location_kind.clone()); + metadata.location_id.swap_root(location.root().clone()); + id_to_location.insert(op_id, metadata.location_id.clone()); return false; } } diff --git a/hydro_optimize/src/rewrites.rs b/hydro_optimize/src/rewrites.rs index 7a26a3b..33a9b78 100644 --- a/hydro_optimize/src/rewrites.rs +++ b/hydro_optimize/src/rewrites.rs @@ -8,7 +8,7 @@ use hydro_lang::compile::ir::{ }; use hydro_lang::deploy::HydroDeploy; use hydro_lang::location::dynamic::LocationId; -use hydro_lang::location::{Cluster, Location}; +use hydro_lang::location::{Cluster, Location, LocationKey}; use proc_macro2::{Span, TokenStream}; use quote::quote; use serde::{Deserialize, Serialize}; @@ -37,46 +37,44 @@ pub type Rewrites = Vec; /// Returns Vec(Cluster, number of nodes) for each created cluster and a new FlowBuilder pub fn replay<'a>( rewrites: &mut Rewrites, - builder: RewriteIrFlowBuilder<'a>, + builder: FlowBuilder<'a>, ir: &[HydroRoot], ) -> (Vec<(Cluster<'a, ()>, usize)>, FlowBuilder<'a>) { let mut new_clusters = vec![]; let multi_run_metadata = RefCell::new(vec![]); - let new_builder = builder.build_with(|builder| { - let mut ir = deep_clone(ir); + let mut ir = deep_clone(ir); - // Apply decoupling/partitioning in order - for rewrite_metadata in rewrites.iter_mut() { - let new_cluster = builder.cluster::<()>(); - match &mut rewrite_metadata.rewrite { - Rewrite::Decouple(decoupler) => { - decoupler.decoupled_location = new_cluster.id().clone(); - decoupler::decouple(&mut ir, decoupler, &multi_run_metadata, 0); - } - Rewrite::Partition(_partitioner) => { - panic!("Partitioning is not yet replayable"); - } + // Apply decoupling/partitioning in order + for rewrite_metadata in rewrites.iter_mut() { + let new_cluster = builder.cluster::<()>(); + match &mut rewrite_metadata.rewrite { + Rewrite::Decouple(decoupler) => { + decoupler.decoupled_location = new_cluster.id().clone(); + decoupler::decouple(&mut ir, decoupler, &multi_run_metadata, 0); + } + Rewrite::Partition(_partitioner) => { + panic!("Partitioning is not yet replayable"); } - new_clusters.push((new_cluster, rewrite_metadata.num_nodes)); } + new_clusters.push((new_cluster, rewrite_metadata.num_nodes)); + } - ir - }); + builder.force_roots(ir); - (new_clusters, new_builder) + (new_clusters, builder) } /// Replace CLUSTER_SELF_ID with the ID of the original node the partition is assigned to #[derive(Copy, Clone)] pub enum ClusterSelfIdReplace { Decouple { - orig_cluster_id: usize, - decoupled_cluster_id: usize, + orig_cluster_id: LocationKey, + decoupled_cluster_id: LocationKey, }, Partition { num_partitions: usize, - partitioned_cluster_id: usize, + partitioned_cluster_id: LocationKey, op_id: usize, }, } @@ -128,13 +126,13 @@ impl VisitMut for ClusterSelfIdReplace { /// Converts input metadata to IDs, filtering by location if provided pub fn relevant_inputs( input_metadatas: Vec<&HydroIrMetadata>, - location: Option<&LocationId>, + location: Option<&LocationKey>, ) -> Vec { input_metadatas .iter() .filter_map(|input_metadata| { if let Some(location) = location - && input_metadata.location_kind.root() != location + && input_metadata.location_id.root().key() != *location { None } else { @@ -147,7 +145,7 @@ pub fn relevant_inputs( /// Creates a mapping from op_id to its input op_ids, filtered by location if provided pub fn op_id_to_inputs( ir: &mut [HydroRoot], - location: Option<&LocationId>, + location: Option<&LocationKey>, cycle_source_to_sink_input: &HashMap, ) -> HashMap> { let mapping = RefCell::new(HashMap::new()); @@ -199,15 +197,15 @@ pub enum NetworkType { SendRecv, } -pub fn get_network_type(node: &HydroNode, location: usize) -> Option { +pub fn get_network_type(node: &HydroNode, location: &LocationKey) -> Option { let mut is_to_us = false; let mut is_from_us = false; if let HydroNode::Network { input, .. } = node { - if input.metadata().location_kind.root().raw_id() == location { + if input.metadata().location_id.root().key() == *location { is_from_us = true; } - if node.metadata().location_kind.root().raw_id() == location { + if node.metadata().location_id.root().key() == *location { is_to_us = true; } diff --git a/hydro_optimize/src/snapshots/hydro_optimize__decoupler__tests__decouple_after_source_ir.snap b/hydro_optimize/src/snapshots/hydro_optimize__decoupler__tests__decouple_after_source_ir.snap index 7e4f1ee..5b1b9e0 100644 --- a/hydro_optimize/src/snapshots/hydro_optimize__decoupler__tests__decouple_after_source_ir.snap +++ b/hydro_optimize/src/snapshots/hydro_optimize__decoupler__tests__decouple_after_source_ir.snap @@ -42,7 +42,7 @@ expression: built.ir() ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -54,7 +54,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -66,7 +66,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -79,7 +79,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedSingleton { @@ -90,7 +90,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 2, @@ -104,7 +104,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 2, @@ -118,7 +118,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 2, @@ -134,7 +134,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 2, @@ -149,7 +149,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 2, @@ -165,7 +165,7 @@ expression: built.ir() }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 2, @@ -199,7 +199,7 @@ expression: built.ir() stageleft :: runtime_support :: type_hint :: < std :: ops :: Range < i32 > > ({ use crate :: __staged :: __deps :: * ; use crate :: __staged :: decoupler :: tests :: * ; 0 .. 10 }), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 0, ), collection_kind: Stream { @@ -211,7 +211,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 0, ), collection_kind: KeyedStream { @@ -224,7 +224,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -237,7 +237,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -249,7 +249,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -261,7 +261,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 2, @@ -276,7 +276,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 2, @@ -291,7 +291,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 2, @@ -307,7 +307,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -320,7 +320,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -332,7 +332,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -345,7 +345,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -357,7 +357,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -370,7 +370,7 @@ expression: built.ir() }, trusted: false, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { diff --git a/hydro_optimize/src/snapshots/hydro_optimize__decoupler__tests__move_source_decouple_map_ir.snap b/hydro_optimize/src/snapshots/hydro_optimize__decoupler__tests__move_source_decouple_map_ir.snap index 6eed208..621e9a7 100644 --- a/hydro_optimize/src/snapshots/hydro_optimize__decoupler__tests__move_source_decouple_map_ir.snap +++ b/hydro_optimize/src/snapshots/hydro_optimize__decoupler__tests__move_source_decouple_map_ir.snap @@ -42,7 +42,7 @@ expression: built.ir() ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 0, ), collection_kind: Stream { @@ -54,7 +54,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 0, ), collection_kind: Stream { @@ -66,7 +66,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 0, ), collection_kind: KeyedStream { @@ -79,7 +79,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 0, ), collection_kind: KeyedSingleton { @@ -90,7 +90,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 0, @@ -104,7 +104,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 0, @@ -118,7 +118,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 0, @@ -134,7 +134,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 0, @@ -149,7 +149,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 0, @@ -165,7 +165,7 @@ expression: built.ir() }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 0, @@ -199,7 +199,7 @@ expression: built.ir() stageleft :: runtime_support :: type_hint :: < std :: ops :: Range < i32 > > ({ use crate :: __staged :: __deps :: * ; use crate :: __staged :: decoupler :: tests :: * ; 0 .. 10 }), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -211,7 +211,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -223,7 +223,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -236,7 +236,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 0, ), collection_kind: KeyedStream { @@ -249,7 +249,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 0, ), collection_kind: Stream { @@ -261,7 +261,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 0, @@ -276,7 +276,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 0, @@ -291,7 +291,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 0, @@ -307,7 +307,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 0, ), collection_kind: KeyedStream { @@ -320,7 +320,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -332,7 +332,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -345,7 +345,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -357,7 +357,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -370,7 +370,7 @@ expression: built.ir() }, trusted: false, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { diff --git a/hydro_optimize/src/tests/mod.rs b/hydro_optimize/src/tests/mod.rs index db3f544..fb335db 100644 --- a/hydro_optimize/src/tests/mod.rs +++ b/hydro_optimize/src/tests/mod.rs @@ -15,8 +15,8 @@ struct DecoupledCluster; #[test] fn decoupled_compute_pi_ir() { - let builder = FlowBuilder::new(); - let (cluster, _) = hydro_test::cluster::compute_pi::compute_pi(&builder, 8192); + let mut builder = FlowBuilder::new(); + let (cluster, _) = hydro_test::cluster::compute_pi::compute_pi(&mut builder, 8192); let decoupled_cluster = builder.cluster::(); let decoupler = decoupler::Decoupler { output_to_decoupled_machine_after: vec![4], @@ -43,12 +43,12 @@ fn decoupled_compute_pi_ir() { #[test] fn partitioned_simple_cluster_ir() { - let builder = FlowBuilder::new(); - let (_, cluster) = hydro_test::cluster::simple_cluster::simple_cluster(&builder); + let mut builder = FlowBuilder::new(); + let (_, cluster) = hydro_test::cluster::simple_cluster::simple_cluster(&mut builder); let partitioner = Partitioner { nodes_to_partition: HashMap::from([(5, vec!["1".to_string()])]), num_partitions: 3, - location_id: cluster.id().raw_id(), + location_id: cluster.id().key(), new_cluster_id: None, }; let mut built = builder diff --git a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir.snap b/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir.snap index b3fdca1..78ed060 100644 --- a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir.snap +++ b/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir.snap @@ -57,7 +57,7 @@ expression: built.ir() input: Source { source: Spin, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 0, ), collection_kind: Stream { @@ -69,7 +69,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 0, ), collection_kind: Stream { @@ -81,7 +81,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 0, ), collection_kind: Stream { @@ -93,7 +93,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 0, @@ -108,7 +108,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 0, @@ -123,7 +123,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 0, ), collection_kind: KeyedStream { @@ -136,7 +136,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -149,7 +149,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -161,7 +161,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 2, @@ -176,7 +176,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 2, @@ -189,7 +189,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 2, @@ -204,7 +204,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -216,7 +216,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 1, ), collection_kind: Stream { @@ -228,7 +228,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 1, ), collection_kind: KeyedStream { @@ -241,7 +241,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 1, ), collection_kind: Stream { @@ -253,7 +253,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 1, ), collection_kind: Stream { @@ -266,7 +266,7 @@ expression: built.ir() }, trusted: false, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 1, ), collection_kind: Stream { @@ -278,7 +278,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 1, ), collection_kind: Optional { @@ -288,7 +288,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 1, @@ -310,7 +310,7 @@ expression: built.ir() { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: compute_pi :: * ; Duration :: from_secs (1) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 1, ), collection_kind: Stream { @@ -322,7 +322,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 1, @@ -337,7 +337,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 1, @@ -350,7 +350,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 1, @@ -363,7 +363,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 1, @@ -376,7 +376,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 1, @@ -389,7 +389,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 1, @@ -404,7 +404,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 1, ), collection_kind: Stream { @@ -416,7 +416,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 1, ), collection_kind: Stream { @@ -429,7 +429,7 @@ expression: built.ir() }, trusted: false, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 1, ), collection_kind: Stream { diff --git a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__partitioned_simple_cluster_ir.snap b/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__partitioned_simple_cluster_ir.snap index e23d4a7..435417e 100644 --- a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__partitioned_simple_cluster_ir.snap +++ b/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__partitioned_simple_cluster_ir.snap @@ -45,7 +45,7 @@ expression: built.ir() ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -57,7 +57,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -69,7 +69,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -82,7 +82,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -94,7 +94,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -112,7 +112,7 @@ expression: built.ir() stageleft :: runtime_support :: type_hint :: < std :: ops :: Range < i32 > > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: simple_cluster :: * ; 0 .. 5 }), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -124,7 +124,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -136,7 +136,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -148,7 +148,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -160,7 +160,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -173,7 +173,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -185,7 +185,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -197,7 +197,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -209,7 +209,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -221,7 +221,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -234,7 +234,7 @@ expression: built.ir() }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -247,7 +247,7 @@ expression: built.ir() }, trusted: false, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { diff --git a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__two_pc__two_pc_partition_coordinator.snap b/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__two_pc__two_pc_partition_coordinator.snap index 1eaf64c..ac6d084 100644 --- a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__two_pc__two_pc_partition_coordinator.snap +++ b/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__two_pc__two_pc_partition_coordinator.snap @@ -16,7 +16,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -31,7 +31,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -97,7 +97,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -109,7 +109,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -121,7 +121,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -134,7 +134,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -145,7 +145,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -159,7 +159,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -173,7 +173,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -189,7 +189,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -204,7 +204,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -220,7 +220,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -252,7 +252,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -264,7 +264,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: KeyedStream { @@ -277,7 +277,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -289,7 +289,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -302,7 +302,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -314,7 +314,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -329,7 +329,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -344,7 +344,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -360,7 +360,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -373,7 +373,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -385,7 +385,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -397,7 +397,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -410,7 +410,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -422,7 +422,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -435,7 +435,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -447,7 +447,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -459,7 +459,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -471,7 +471,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -483,7 +483,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -498,7 +498,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -513,7 +513,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -546,7 +546,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -561,7 +561,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -627,7 +627,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -639,7 +639,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -651,7 +651,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -664,7 +664,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -675,7 +675,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -689,7 +689,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -703,7 +703,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -719,7 +719,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -734,7 +734,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -750,7 +750,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -782,7 +782,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -794,7 +794,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: KeyedStream { @@ -807,7 +807,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -819,7 +819,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -832,7 +832,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -844,7 +844,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -859,7 +859,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -874,7 +874,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -890,7 +890,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -903,7 +903,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -915,7 +915,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -927,7 +927,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -940,7 +940,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -952,7 +952,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -965,7 +965,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -977,7 +977,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -989,7 +989,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -1001,7 +1001,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -1013,7 +1013,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -1028,7 +1028,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -1043,7 +1043,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -1058,7 +1058,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -1075,7 +1075,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -1091,7 +1091,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -1105,7 +1105,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -1119,7 +1119,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -1135,7 +1135,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -1150,7 +1150,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -1165,7 +1165,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -1180,7 +1180,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -1206,7 +1206,7 @@ expression: "&ir" sym: cycle_2, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -1221,7 +1221,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -1250,7 +1250,7 @@ expression: "&ir" sym: cycle_3, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -1265,7 +1265,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -1331,7 +1331,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -1343,7 +1343,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -1355,7 +1355,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -1368,7 +1368,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -1379,7 +1379,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -1393,7 +1393,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -1407,7 +1407,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -1423,7 +1423,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -1438,7 +1438,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -1454,7 +1454,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -1489,7 +1489,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -1504,7 +1504,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -1570,7 +1570,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -1582,7 +1582,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -1594,7 +1594,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -1607,7 +1607,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -1618,7 +1618,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -1632,7 +1632,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -1646,7 +1646,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -1662,7 +1662,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -1677,7 +1677,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -1693,7 +1693,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -1725,7 +1725,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -1737,7 +1737,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: KeyedStream { @@ -1750,7 +1750,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -1762,7 +1762,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -1775,7 +1775,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -1787,7 +1787,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -1802,7 +1802,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -1817,7 +1817,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -1833,7 +1833,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -1846,7 +1846,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -1858,7 +1858,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -1870,7 +1870,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -1883,7 +1883,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -1895,7 +1895,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -1908,7 +1908,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -1920,7 +1920,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -1932,7 +1932,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -1944,7 +1944,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -1956,7 +1956,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -1971,7 +1971,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -1986,7 +1986,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -2001,7 +2001,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -2018,7 +2018,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -2034,7 +2034,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -2048,7 +2048,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -2062,7 +2062,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -2078,7 +2078,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -2093,7 +2093,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -2108,7 +2108,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -2123,7 +2123,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -2135,7 +2135,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -2150,7 +2150,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -2165,7 +2165,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -2181,7 +2181,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -2194,7 +2194,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -2206,7 +2206,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -2218,7 +2218,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -2231,7 +2231,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -2243,7 +2243,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -2256,7 +2256,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -2268,7 +2268,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -2280,7 +2280,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -2292,7 +2292,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -2304,7 +2304,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -2319,7 +2319,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -2334,7 +2334,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -2367,7 +2367,7 @@ expression: "&ir" sym: cycle_3, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -2382,7 +2382,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -2448,7 +2448,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -2460,7 +2460,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -2472,7 +2472,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -2485,7 +2485,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -2496,7 +2496,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -2510,7 +2510,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -2524,7 +2524,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -2540,7 +2540,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -2555,7 +2555,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -2571,7 +2571,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -2606,7 +2606,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -2621,7 +2621,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -2687,7 +2687,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -2699,7 +2699,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -2711,7 +2711,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -2724,7 +2724,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -2735,7 +2735,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -2749,7 +2749,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -2763,7 +2763,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -2779,7 +2779,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -2794,7 +2794,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -2810,7 +2810,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -2842,7 +2842,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -2854,7 +2854,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: KeyedStream { @@ -2867,7 +2867,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -2879,7 +2879,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -2892,7 +2892,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -2904,7 +2904,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -2919,7 +2919,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -2934,7 +2934,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -2950,7 +2950,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -2963,7 +2963,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -2975,7 +2975,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -2987,7 +2987,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -3000,7 +3000,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -3012,7 +3012,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -3025,7 +3025,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -3037,7 +3037,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -3049,7 +3049,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -3061,7 +3061,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -3073,7 +3073,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -3088,7 +3088,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -3103,7 +3103,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -3118,7 +3118,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -3135,7 +3135,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -3151,7 +3151,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -3165,7 +3165,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -3179,7 +3179,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -3195,7 +3195,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -3210,7 +3210,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -3225,7 +3225,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -3240,7 +3240,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -3252,7 +3252,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -3267,7 +3267,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -3282,7 +3282,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -3298,7 +3298,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -3311,7 +3311,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -3323,7 +3323,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -3335,7 +3335,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -3348,7 +3348,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -3360,7 +3360,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -3373,7 +3373,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -3385,7 +3385,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -3397,7 +3397,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -3409,7 +3409,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -3421,7 +3421,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -3436,7 +3436,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -3451,7 +3451,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -3466,7 +3466,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -3483,7 +3483,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -3499,7 +3499,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -3513,7 +3513,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -3527,7 +3527,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -3543,7 +3543,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -3558,7 +3558,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -3573,7 +3573,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -3588,7 +3588,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -3614,7 +3614,7 @@ expression: "&ir" sym: cycle_4, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -3629,7 +3629,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -3659,7 +3659,7 @@ expression: "&ir" sym: cycle_5, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -3672,7 +3672,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -3691,7 +3691,7 @@ expression: "&ir" inner: SingletonSource { value: { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; 0u32 }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -3704,7 +3704,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -3724,7 +3724,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: tick :: * ; let e__free = { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; () } ; [e__free] }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Optional { @@ -3734,7 +3734,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -3747,7 +3747,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -3760,7 +3760,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -3773,7 +3773,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -3786,7 +3786,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -3799,7 +3799,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -3812,7 +3812,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -3843,7 +3843,7 @@ expression: "&ir" sym: cycle_6, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -3857,7 +3857,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -3871,7 +3871,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -3885,7 +3885,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -3913,7 +3913,7 @@ expression: "&ir" sym: cycle_5, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -3926,7 +3926,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -3945,7 +3945,7 @@ expression: "&ir" inner: SingletonSource { value: { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; 0u32 }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -3958,7 +3958,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -3978,7 +3978,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: tick :: * ; let e__free = { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; () } ; [e__free] }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Optional { @@ -3988,7 +3988,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -4001,7 +4001,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -4014,7 +4014,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -4027,7 +4027,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -4040,7 +4040,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -4053,7 +4053,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -4066,7 +4066,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -4081,7 +4081,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -4096,7 +4096,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -4111,7 +4111,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -4127,7 +4127,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -4181,7 +4181,7 @@ expression: "&ir" sym: cycle_3, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -4196,7 +4196,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -4262,7 +4262,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -4274,7 +4274,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -4286,7 +4286,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -4299,7 +4299,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -4310,7 +4310,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -4324,7 +4324,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -4338,7 +4338,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -4354,7 +4354,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -4369,7 +4369,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -4385,7 +4385,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -4420,7 +4420,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -4435,7 +4435,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -4501,7 +4501,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -4513,7 +4513,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -4525,7 +4525,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -4538,7 +4538,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -4549,7 +4549,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -4563,7 +4563,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -4577,7 +4577,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -4593,7 +4593,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -4608,7 +4608,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -4624,7 +4624,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -4656,7 +4656,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -4668,7 +4668,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: KeyedStream { @@ -4681,7 +4681,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -4693,7 +4693,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -4706,7 +4706,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -4718,7 +4718,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -4733,7 +4733,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -4748,7 +4748,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -4764,7 +4764,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -4777,7 +4777,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -4789,7 +4789,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -4801,7 +4801,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -4814,7 +4814,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -4826,7 +4826,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -4839,7 +4839,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -4851,7 +4851,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -4863,7 +4863,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -4875,7 +4875,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -4887,7 +4887,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -4902,7 +4902,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -4917,7 +4917,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -4932,7 +4932,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -4949,7 +4949,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -4965,7 +4965,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -4979,7 +4979,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -4993,7 +4993,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -5009,7 +5009,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -5024,7 +5024,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -5039,7 +5039,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -5054,7 +5054,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -5066,7 +5066,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -5081,7 +5081,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -5096,7 +5096,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -5112,7 +5112,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -5125,7 +5125,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -5137,7 +5137,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -5149,7 +5149,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -5162,7 +5162,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -5174,7 +5174,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -5187,7 +5187,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -5199,7 +5199,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -5211,7 +5211,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -5223,7 +5223,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -5235,7 +5235,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -5250,7 +5250,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -5265,7 +5265,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -5280,7 +5280,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -5297,7 +5297,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -5313,7 +5313,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -5327,7 +5327,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -5341,7 +5341,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -5357,7 +5357,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -5372,7 +5372,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -5387,7 +5387,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -5402,7 +5402,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -5414,7 +5414,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -5427,7 +5427,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -5439,7 +5439,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -5451,7 +5451,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: KeyedStream { @@ -5464,7 +5464,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5480,7 +5480,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5496,7 +5496,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5512,7 +5512,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5528,7 +5528,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5544,7 +5544,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5561,7 +5561,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5577,7 +5577,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5615,7 +5615,7 @@ expression: "&ir" sym: cycle_5, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5628,7 +5628,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5647,7 +5647,7 @@ expression: "&ir" inner: SingletonSource { value: { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; 0u32 }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5660,7 +5660,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5680,7 +5680,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: tick :: * ; let e__free = { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; () } ; [e__free] }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Optional { @@ -5690,7 +5690,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5703,7 +5703,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5716,7 +5716,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5729,7 +5729,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5742,7 +5742,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5755,7 +5755,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5768,7 +5768,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5783,7 +5783,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5798,7 +5798,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5813,7 +5813,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -5864,7 +5864,7 @@ expression: "&ir" sym: cycle_3, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -5879,7 +5879,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -5945,7 +5945,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -5957,7 +5957,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -5969,7 +5969,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -5982,7 +5982,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -5993,7 +5993,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -6007,7 +6007,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -6021,7 +6021,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -6037,7 +6037,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -6052,7 +6052,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -6068,7 +6068,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -6103,7 +6103,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -6118,7 +6118,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -6184,7 +6184,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -6196,7 +6196,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -6208,7 +6208,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -6221,7 +6221,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -6232,7 +6232,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -6246,7 +6246,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -6260,7 +6260,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -6276,7 +6276,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -6291,7 +6291,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -6307,7 +6307,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -6339,7 +6339,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -6351,7 +6351,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: KeyedStream { @@ -6364,7 +6364,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -6376,7 +6376,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -6389,7 +6389,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -6401,7 +6401,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -6416,7 +6416,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -6431,7 +6431,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -6447,7 +6447,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -6460,7 +6460,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -6472,7 +6472,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -6484,7 +6484,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -6497,7 +6497,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -6509,7 +6509,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -6522,7 +6522,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -6534,7 +6534,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -6546,7 +6546,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -6558,7 +6558,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -6570,7 +6570,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -6585,7 +6585,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -6600,7 +6600,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -6615,7 +6615,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -6632,7 +6632,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -6648,7 +6648,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -6662,7 +6662,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -6676,7 +6676,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -6692,7 +6692,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -6707,7 +6707,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -6722,7 +6722,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -6737,7 +6737,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -6749,7 +6749,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -6764,7 +6764,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -6779,7 +6779,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -6795,7 +6795,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -6808,7 +6808,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -6820,7 +6820,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -6832,7 +6832,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -6845,7 +6845,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -6857,7 +6857,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -6870,7 +6870,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -6882,7 +6882,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -6894,7 +6894,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -6906,7 +6906,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -6918,7 +6918,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -6933,7 +6933,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -6948,7 +6948,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -6963,7 +6963,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -6980,7 +6980,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -6996,7 +6996,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -7010,7 +7010,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -7024,7 +7024,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -7040,7 +7040,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -7055,7 +7055,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -7070,7 +7070,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -7085,7 +7085,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -7097,7 +7097,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -7110,7 +7110,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -7122,7 +7122,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -7134,7 +7134,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: KeyedStream { @@ -7147,7 +7147,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -7163,7 +7163,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -7179,7 +7179,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -7195,7 +7195,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -7211,7 +7211,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: KeyedStream { @@ -7224,7 +7224,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -7236,7 +7236,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -7249,7 +7249,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -7301,7 +7301,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -7313,7 +7313,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -7325,7 +7325,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedStream { @@ -7338,7 +7338,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedSingleton { @@ -7349,7 +7349,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -7363,7 +7363,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -7377,7 +7377,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -7393,7 +7393,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -7409,7 +7409,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -7424,7 +7424,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -7437,7 +7437,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -7531,7 +7531,7 @@ expression: "&ir" sym: cycle_3, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -7546,7 +7546,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -7612,7 +7612,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -7624,7 +7624,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -7636,7 +7636,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -7649,7 +7649,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -7660,7 +7660,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -7674,7 +7674,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -7688,7 +7688,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -7704,7 +7704,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -7719,7 +7719,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -7735,7 +7735,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -7770,7 +7770,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -7785,7 +7785,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -7851,7 +7851,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -7863,7 +7863,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -7875,7 +7875,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -7888,7 +7888,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -7899,7 +7899,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -7913,7 +7913,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -7927,7 +7927,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -7943,7 +7943,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -7958,7 +7958,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -7974,7 +7974,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -8006,7 +8006,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -8018,7 +8018,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: KeyedStream { @@ -8031,7 +8031,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -8043,7 +8043,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -8056,7 +8056,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -8068,7 +8068,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -8083,7 +8083,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -8098,7 +8098,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -8114,7 +8114,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -8127,7 +8127,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -8139,7 +8139,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -8151,7 +8151,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -8164,7 +8164,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -8176,7 +8176,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -8189,7 +8189,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -8201,7 +8201,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -8213,7 +8213,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -8225,7 +8225,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -8237,7 +8237,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -8252,7 +8252,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -8267,7 +8267,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -8282,7 +8282,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -8299,7 +8299,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -8315,7 +8315,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -8329,7 +8329,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -8343,7 +8343,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -8359,7 +8359,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -8374,7 +8374,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -8389,7 +8389,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -8404,7 +8404,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -8416,7 +8416,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -8431,7 +8431,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -8446,7 +8446,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -8462,7 +8462,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -8475,7 +8475,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -8487,7 +8487,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -8499,7 +8499,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -8512,7 +8512,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -8524,7 +8524,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -8537,7 +8537,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -8549,7 +8549,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -8561,7 +8561,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -8573,7 +8573,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -8585,7 +8585,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -8600,7 +8600,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -8615,7 +8615,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -8630,7 +8630,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -8647,7 +8647,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -8663,7 +8663,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -8677,7 +8677,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -8691,7 +8691,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -8707,7 +8707,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -8722,7 +8722,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -8737,7 +8737,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -8752,7 +8752,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -8764,7 +8764,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -8777,7 +8777,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -8789,7 +8789,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -8801,7 +8801,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: KeyedStream { @@ -8814,7 +8814,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -8830,7 +8830,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -8846,7 +8846,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -8862,7 +8862,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -8877,7 +8877,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -8893,7 +8893,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -8908,7 +8908,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -8921,7 +8921,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -8936,7 +8936,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -8948,7 +8948,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -8966,7 +8966,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_secs (1) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -8978,7 +8978,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -8990,7 +8990,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -9002,7 +9002,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Singleton { @@ -9012,7 +9012,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Singleton { @@ -9022,7 +9022,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -9044,7 +9044,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -9056,7 +9056,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -9071,7 +9071,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -9084,7 +9084,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -9097,7 +9097,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -9110,7 +9110,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -9123,7 +9123,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -9138,7 +9138,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -9150,7 +9150,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -9162,7 +9162,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -9174,7 +9174,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedStream { @@ -9188,7 +9188,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedStream { @@ -9201,7 +9201,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedSingleton { @@ -9212,7 +9212,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedSingleton { @@ -9223,7 +9223,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -9237,7 +9237,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -9251,7 +9251,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -9267,7 +9267,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -9283,7 +9283,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -9298,7 +9298,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -9311,7 +9311,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -9324,7 +9324,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -9337,7 +9337,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -9350,7 +9350,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -9363,7 +9363,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -9378,7 +9378,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -9390,7 +9390,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 7, Process( 4, @@ -9414,7 +9414,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -9426,7 +9426,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 7, Process( 4, @@ -9441,7 +9441,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 7, Process( 4, @@ -9454,7 +9454,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 7, Process( 4, @@ -9467,7 +9467,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 7, Process( 4, @@ -9482,7 +9482,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 7, Process( 4, @@ -9497,7 +9497,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -9509,7 +9509,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -9522,7 +9522,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -9631,7 +9631,7 @@ expression: "&ir" sym: cycle_3, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -9646,7 +9646,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -9712,7 +9712,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -9724,7 +9724,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -9736,7 +9736,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -9749,7 +9749,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -9760,7 +9760,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -9774,7 +9774,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -9788,7 +9788,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -9804,7 +9804,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -9819,7 +9819,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -9835,7 +9835,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -9870,7 +9870,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -9885,7 +9885,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -9951,7 +9951,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -9963,7 +9963,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -9975,7 +9975,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -9988,7 +9988,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -9999,7 +9999,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -10013,7 +10013,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -10027,7 +10027,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -10043,7 +10043,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -10058,7 +10058,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -10074,7 +10074,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -10106,7 +10106,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -10118,7 +10118,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: KeyedStream { @@ -10131,7 +10131,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -10143,7 +10143,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -10156,7 +10156,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -10168,7 +10168,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -10183,7 +10183,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -10198,7 +10198,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -10214,7 +10214,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -10227,7 +10227,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -10239,7 +10239,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -10251,7 +10251,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -10264,7 +10264,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -10276,7 +10276,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -10289,7 +10289,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -10301,7 +10301,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -10313,7 +10313,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -10325,7 +10325,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -10337,7 +10337,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -10352,7 +10352,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -10367,7 +10367,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -10382,7 +10382,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -10399,7 +10399,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -10415,7 +10415,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -10429,7 +10429,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -10443,7 +10443,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -10459,7 +10459,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -10474,7 +10474,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -10489,7 +10489,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -10504,7 +10504,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -10516,7 +10516,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -10531,7 +10531,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -10546,7 +10546,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -10562,7 +10562,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -10575,7 +10575,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -10587,7 +10587,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -10599,7 +10599,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -10612,7 +10612,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -10624,7 +10624,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -10637,7 +10637,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -10649,7 +10649,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -10661,7 +10661,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -10673,7 +10673,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -10685,7 +10685,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -10700,7 +10700,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -10715,7 +10715,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -10730,7 +10730,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -10747,7 +10747,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -10763,7 +10763,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -10777,7 +10777,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -10791,7 +10791,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -10807,7 +10807,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -10822,7 +10822,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -10837,7 +10837,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -10852,7 +10852,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -10864,7 +10864,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -10877,7 +10877,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -10889,7 +10889,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -10901,7 +10901,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: KeyedStream { @@ -10914,7 +10914,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -10930,7 +10930,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -10946,7 +10946,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -10962,7 +10962,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -10977,7 +10977,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -10993,7 +10993,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -11008,7 +11008,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -11021,7 +11021,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -11036,7 +11036,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -11048,7 +11048,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -11066,7 +11066,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_secs (1) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -11078,7 +11078,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -11090,7 +11090,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -11102,7 +11102,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Singleton { @@ -11112,7 +11112,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Singleton { @@ -11122,7 +11122,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -11144,7 +11144,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -11156,7 +11156,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -11171,7 +11171,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -11184,7 +11184,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -11197,7 +11197,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -11210,7 +11210,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -11223,7 +11223,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -11238,7 +11238,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -11250,7 +11250,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -11262,7 +11262,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -11274,7 +11274,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedStream { @@ -11288,7 +11288,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedStream { @@ -11301,7 +11301,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedSingleton { @@ -11312,7 +11312,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedSingleton { @@ -11323,7 +11323,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 8, Process( 4, @@ -11337,7 +11337,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 8, Process( 4, @@ -11353,7 +11353,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 8, Process( 4, @@ -11368,7 +11368,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 8, Process( 4, @@ -11381,7 +11381,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Optional { @@ -11391,7 +11391,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 9, Process( 4, @@ -11413,7 +11413,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -11425,7 +11425,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 9, Process( 4, @@ -11440,7 +11440,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 9, Process( 4, @@ -11453,7 +11453,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 9, Process( 4, @@ -11466,7 +11466,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 9, Process( 4, @@ -11479,7 +11479,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 9, Process( 4, @@ -11492,7 +11492,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 9, Process( 4, @@ -11507,7 +11507,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -11519,7 +11519,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -11531,7 +11531,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -11569,7 +11569,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -11581,7 +11581,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -11593,7 +11593,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedStream { @@ -11606,7 +11606,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedSingleton { @@ -11617,7 +11617,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -11631,7 +11631,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -11645,7 +11645,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -11661,7 +11661,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -11677,7 +11677,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -11692,7 +11692,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -11705,7 +11705,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -11718,7 +11718,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -11731,7 +11731,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -11783,7 +11783,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -11795,7 +11795,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -11807,7 +11807,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedStream { @@ -11820,7 +11820,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedSingleton { @@ -11831,7 +11831,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -11845,7 +11845,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -11859,7 +11859,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -11875,7 +11875,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -11891,7 +11891,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -11906,7 +11906,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -11919,7 +11919,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -12013,7 +12013,7 @@ expression: "&ir" sym: cycle_3, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -12028,7 +12028,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -12094,7 +12094,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -12106,7 +12106,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -12118,7 +12118,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -12131,7 +12131,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -12142,7 +12142,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -12156,7 +12156,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -12170,7 +12170,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -12186,7 +12186,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -12201,7 +12201,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -12217,7 +12217,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -12252,7 +12252,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -12267,7 +12267,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -12333,7 +12333,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -12345,7 +12345,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -12357,7 +12357,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -12370,7 +12370,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -12381,7 +12381,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -12395,7 +12395,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -12409,7 +12409,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -12425,7 +12425,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -12440,7 +12440,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -12456,7 +12456,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -12488,7 +12488,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -12500,7 +12500,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: KeyedStream { @@ -12513,7 +12513,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -12525,7 +12525,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -12538,7 +12538,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -12550,7 +12550,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -12565,7 +12565,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -12580,7 +12580,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -12596,7 +12596,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -12609,7 +12609,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -12621,7 +12621,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -12633,7 +12633,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -12646,7 +12646,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -12658,7 +12658,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -12671,7 +12671,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -12683,7 +12683,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -12695,7 +12695,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -12707,7 +12707,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -12719,7 +12719,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -12734,7 +12734,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -12749,7 +12749,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -12764,7 +12764,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -12781,7 +12781,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -12797,7 +12797,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -12811,7 +12811,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -12825,7 +12825,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -12841,7 +12841,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -12856,7 +12856,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -12871,7 +12871,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -12886,7 +12886,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -12898,7 +12898,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -12913,7 +12913,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -12928,7 +12928,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -12944,7 +12944,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -12957,7 +12957,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -12969,7 +12969,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -12981,7 +12981,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -12994,7 +12994,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -13006,7 +13006,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -13019,7 +13019,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -13031,7 +13031,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -13043,7 +13043,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -13055,7 +13055,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -13067,7 +13067,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -13082,7 +13082,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -13097,7 +13097,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -13112,7 +13112,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -13129,7 +13129,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -13145,7 +13145,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -13159,7 +13159,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -13173,7 +13173,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -13189,7 +13189,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -13204,7 +13204,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -13219,7 +13219,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -13234,7 +13234,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -13246,7 +13246,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -13259,7 +13259,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -13271,7 +13271,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -13283,7 +13283,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: KeyedStream { @@ -13296,7 +13296,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -13312,7 +13312,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -13328,7 +13328,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -13344,7 +13344,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -13359,7 +13359,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -13375,7 +13375,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -13390,7 +13390,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -13403,7 +13403,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -13418,7 +13418,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -13430,7 +13430,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -13448,7 +13448,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_secs (1) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -13460,7 +13460,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -13472,7 +13472,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -13484,7 +13484,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Singleton { @@ -13494,7 +13494,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Singleton { @@ -13504,7 +13504,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -13526,7 +13526,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -13538,7 +13538,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -13553,7 +13553,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -13566,7 +13566,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -13579,7 +13579,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -13592,7 +13592,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -13605,7 +13605,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -13620,7 +13620,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -13632,7 +13632,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -13644,7 +13644,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -13656,7 +13656,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedStream { @@ -13670,7 +13670,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedStream { @@ -13683,7 +13683,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedSingleton { @@ -13694,7 +13694,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedSingleton { @@ -13705,7 +13705,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13719,7 +13719,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13733,7 +13733,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13749,7 +13749,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13765,7 +13765,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13780,7 +13780,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13793,7 +13793,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13806,7 +13806,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13819,7 +13819,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13832,7 +13832,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13845,7 +13845,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13858,7 +13858,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13874,7 +13874,7 @@ expression: "&ir" inner: SingletonSource { value: :: std :: option :: Option :: None, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13887,7 +13887,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13900,7 +13900,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13913,7 +13913,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13926,7 +13926,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13939,7 +13939,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13952,7 +13952,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13967,7 +13967,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -13982,7 +13982,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -13995,7 +13995,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -14074,7 +14074,7 @@ expression: "&ir" sym: cycle_6, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -14088,7 +14088,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -14102,7 +14102,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -14116,7 +14116,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -14132,7 +14132,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -14186,7 +14186,7 @@ expression: "&ir" sym: cycle_3, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -14201,7 +14201,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -14267,7 +14267,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -14279,7 +14279,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -14291,7 +14291,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -14304,7 +14304,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -14315,7 +14315,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -14329,7 +14329,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -14343,7 +14343,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -14359,7 +14359,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -14374,7 +14374,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -14390,7 +14390,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -14425,7 +14425,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -14440,7 +14440,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -14506,7 +14506,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -14518,7 +14518,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -14530,7 +14530,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -14543,7 +14543,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -14554,7 +14554,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -14568,7 +14568,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -14582,7 +14582,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -14598,7 +14598,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -14613,7 +14613,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -14629,7 +14629,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -14661,7 +14661,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -14673,7 +14673,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: KeyedStream { @@ -14686,7 +14686,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -14698,7 +14698,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -14711,7 +14711,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -14723,7 +14723,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -14738,7 +14738,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -14753,7 +14753,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -14769,7 +14769,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -14782,7 +14782,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -14794,7 +14794,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -14806,7 +14806,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -14819,7 +14819,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -14831,7 +14831,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -14844,7 +14844,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -14856,7 +14856,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -14868,7 +14868,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -14880,7 +14880,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -14892,7 +14892,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -14907,7 +14907,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -14922,7 +14922,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -14937,7 +14937,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -14954,7 +14954,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -14970,7 +14970,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -14984,7 +14984,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -14998,7 +14998,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -15014,7 +15014,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -15029,7 +15029,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -15044,7 +15044,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -15059,7 +15059,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -15071,7 +15071,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -15086,7 +15086,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -15101,7 +15101,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -15117,7 +15117,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -15130,7 +15130,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -15142,7 +15142,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -15154,7 +15154,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -15167,7 +15167,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -15179,7 +15179,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -15192,7 +15192,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -15204,7 +15204,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -15216,7 +15216,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -15228,7 +15228,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -15240,7 +15240,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -15255,7 +15255,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -15270,7 +15270,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -15285,7 +15285,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -15302,7 +15302,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -15318,7 +15318,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -15332,7 +15332,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -15346,7 +15346,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -15362,7 +15362,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -15377,7 +15377,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -15392,7 +15392,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -15407,7 +15407,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -15419,7 +15419,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -15432,7 +15432,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -15444,7 +15444,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -15456,7 +15456,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: KeyedStream { @@ -15469,7 +15469,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -15485,7 +15485,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -15501,7 +15501,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -15517,7 +15517,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -15533,7 +15533,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -15549,7 +15549,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -15564,7 +15564,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -15579,7 +15579,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -15595,7 +15595,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -15610,7 +15610,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -15625,7 +15625,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -15640,7 +15640,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -15653,7 +15653,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -15665,7 +15665,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Singleton { @@ -15675,7 +15675,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 10, Cluster( 3, @@ -15697,7 +15697,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -15709,7 +15709,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 10, Cluster( 3, @@ -15724,7 +15724,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 10, Cluster( 3, @@ -15737,7 +15737,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 10, Cluster( 3, @@ -15750,7 +15750,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 10, Cluster( 3, @@ -15763,7 +15763,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 10, Cluster( 3, @@ -15776,7 +15776,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 10, Cluster( 3, @@ -15791,7 +15791,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -15803,7 +15803,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -15815,7 +15815,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -15827,7 +15827,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -15839,7 +15839,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedStream { @@ -15852,7 +15852,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedStream { @@ -15866,7 +15866,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedStream { @@ -15879,7 +15879,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedSingleton { @@ -15890,7 +15890,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 11, Process( 4, @@ -15904,7 +15904,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 11, Process( 4, @@ -15920,7 +15920,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 11, Process( 4, @@ -15935,7 +15935,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 11, Process( 4, @@ -15948,7 +15948,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Optional { @@ -15958,7 +15958,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 12, Process( 4, @@ -15980,7 +15980,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -15992,7 +15992,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 12, Process( 4, @@ -16007,7 +16007,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 12, Process( 4, @@ -16020,7 +16020,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 12, Process( 4, @@ -16033,7 +16033,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 12, Process( 4, @@ -16046,7 +16046,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 12, Process( 4, @@ -16059,7 +16059,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 12, Process( 4, @@ -16074,7 +16074,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -16086,7 +16086,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -16098,7 +16098,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -16150,7 +16150,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -16162,7 +16162,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -16174,7 +16174,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedStream { @@ -16187,7 +16187,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedSingleton { @@ -16198,7 +16198,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -16212,7 +16212,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -16226,7 +16226,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -16242,7 +16242,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -16258,7 +16258,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -16273,7 +16273,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -16286,7 +16286,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -16380,7 +16380,7 @@ expression: "&ir" sym: cycle_3, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -16395,7 +16395,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -16461,7 +16461,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -16473,7 +16473,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -16485,7 +16485,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -16498,7 +16498,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -16509,7 +16509,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -16523,7 +16523,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -16537,7 +16537,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -16553,7 +16553,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -16568,7 +16568,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -16584,7 +16584,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -16619,7 +16619,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -16634,7 +16634,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -16700,7 +16700,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -16712,7 +16712,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -16724,7 +16724,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -16737,7 +16737,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedSingleton { @@ -16748,7 +16748,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -16762,7 +16762,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -16776,7 +16776,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -16792,7 +16792,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -16807,7 +16807,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -16823,7 +16823,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -16855,7 +16855,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -16867,7 +16867,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: KeyedStream { @@ -16880,7 +16880,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -16892,7 +16892,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -16905,7 +16905,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -16917,7 +16917,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -16932,7 +16932,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -16947,7 +16947,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Cluster( 1, @@ -16963,7 +16963,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -16976,7 +16976,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -16988,7 +16988,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -17000,7 +17000,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -17013,7 +17013,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -17025,7 +17025,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -17038,7 +17038,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -17050,7 +17050,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -17062,7 +17062,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -17074,7 +17074,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -17086,7 +17086,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -17101,7 +17101,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -17116,7 +17116,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -17131,7 +17131,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -17148,7 +17148,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -17164,7 +17164,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -17178,7 +17178,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -17192,7 +17192,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -17208,7 +17208,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -17223,7 +17223,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -17238,7 +17238,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Cluster( 1, @@ -17253,7 +17253,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -17265,7 +17265,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -17280,7 +17280,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -17295,7 +17295,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Cluster( 1, @@ -17311,7 +17311,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -17324,7 +17324,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -17336,7 +17336,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -17348,7 +17348,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -17361,7 +17361,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -17373,7 +17373,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -17386,7 +17386,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -17398,7 +17398,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -17410,7 +17410,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -17422,7 +17422,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -17434,7 +17434,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -17449,7 +17449,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -17464,7 +17464,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -17479,7 +17479,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -17496,7 +17496,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -17512,7 +17512,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -17526,7 +17526,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -17540,7 +17540,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -17556,7 +17556,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -17571,7 +17571,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -17586,7 +17586,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Cluster( 1, @@ -17601,7 +17601,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -17613,7 +17613,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: KeyedStream { @@ -17626,7 +17626,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -17638,7 +17638,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -17650,7 +17650,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: KeyedStream { @@ -17663,7 +17663,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -17679,7 +17679,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -17695,7 +17695,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -17711,7 +17711,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -17726,7 +17726,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -17742,7 +17742,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -17757,7 +17757,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -17770,7 +17770,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 3, @@ -17785,7 +17785,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -17797,7 +17797,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -17815,7 +17815,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_secs (1) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -17827,7 +17827,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -17839,7 +17839,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -17851,7 +17851,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Singleton { @@ -17861,7 +17861,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Singleton { @@ -17871,7 +17871,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -17893,7 +17893,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -17905,7 +17905,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -17920,7 +17920,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -17933,7 +17933,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -17946,7 +17946,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -17959,7 +17959,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -17972,7 +17972,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 3, @@ -17987,7 +17987,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -17999,7 +17999,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 3, ), collection_kind: Stream { @@ -18011,7 +18011,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -18023,7 +18023,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedStream { @@ -18037,7 +18037,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedStream { @@ -18050,7 +18050,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedSingleton { @@ -18061,7 +18061,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: KeyedSingleton { @@ -18072,7 +18072,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18086,7 +18086,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18100,7 +18100,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18116,7 +18116,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18132,7 +18132,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18147,7 +18147,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18160,7 +18160,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18173,7 +18173,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18186,7 +18186,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18199,7 +18199,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18212,7 +18212,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18225,7 +18225,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18241,7 +18241,7 @@ expression: "&ir" inner: SingletonSource { value: :: std :: option :: Option :: None, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18254,7 +18254,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18267,7 +18267,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18280,7 +18280,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18293,7 +18293,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18306,7 +18306,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18319,7 +18319,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18334,7 +18334,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 4, @@ -18349,7 +18349,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { @@ -18362,7 +18362,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 4, ), collection_kind: Stream { diff --git a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__two_pc__two_pc_partition_participant.snap b/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__two_pc__two_pc_partition_participant.snap index b2efcc4..1e0aa58 100644 --- a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__two_pc__two_pc_partition_participant.snap +++ b/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__two_pc__two_pc_partition_participant.snap @@ -16,7 +16,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -31,7 +31,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -97,7 +97,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -109,7 +109,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -121,7 +121,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -134,7 +134,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -145,7 +145,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -159,7 +159,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -173,7 +173,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -189,7 +189,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -204,7 +204,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -220,7 +220,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -250,7 +250,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -262,7 +262,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -274,7 +274,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -287,7 +287,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -299,7 +299,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -314,7 +314,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -329,7 +329,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -345,7 +345,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -358,7 +358,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -371,7 +371,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -383,7 +383,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -395,7 +395,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -407,7 +407,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -420,7 +420,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -432,7 +432,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -444,7 +444,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -456,7 +456,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -468,7 +468,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -483,7 +483,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -498,7 +498,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -531,7 +531,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -546,7 +546,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -612,7 +612,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -624,7 +624,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -636,7 +636,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -649,7 +649,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -660,7 +660,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -674,7 +674,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -688,7 +688,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -704,7 +704,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -719,7 +719,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -735,7 +735,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -765,7 +765,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -777,7 +777,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -789,7 +789,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -802,7 +802,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -814,7 +814,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -829,7 +829,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -844,7 +844,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -860,7 +860,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -873,7 +873,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -886,7 +886,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -898,7 +898,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -910,7 +910,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -922,7 +922,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -935,7 +935,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -947,7 +947,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -959,7 +959,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -971,7 +971,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -983,7 +983,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -998,7 +998,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1013,7 +1013,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1028,7 +1028,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1045,7 +1045,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1061,7 +1061,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1075,7 +1075,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1089,7 +1089,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1105,7 +1105,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1120,7 +1120,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1135,7 +1135,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1150,7 +1150,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1176,7 +1176,7 @@ expression: "&ir" sym: cycle_2, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1191,7 +1191,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1220,7 +1220,7 @@ expression: "&ir" sym: cycle_3, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -1235,7 +1235,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -1301,7 +1301,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -1313,7 +1313,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -1325,7 +1325,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -1338,7 +1338,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -1349,7 +1349,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -1363,7 +1363,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -1377,7 +1377,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -1393,7 +1393,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -1408,7 +1408,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -1424,7 +1424,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -1459,7 +1459,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1474,7 +1474,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1540,7 +1540,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -1552,7 +1552,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -1564,7 +1564,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -1577,7 +1577,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -1588,7 +1588,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -1602,7 +1602,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -1616,7 +1616,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -1632,7 +1632,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -1647,7 +1647,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -1663,7 +1663,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -1693,7 +1693,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -1705,7 +1705,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -1717,7 +1717,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -1730,7 +1730,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -1742,7 +1742,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -1757,7 +1757,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -1772,7 +1772,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -1788,7 +1788,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -1801,7 +1801,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -1814,7 +1814,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -1826,7 +1826,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -1838,7 +1838,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -1850,7 +1850,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -1863,7 +1863,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -1875,7 +1875,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -1887,7 +1887,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -1899,7 +1899,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -1911,7 +1911,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1926,7 +1926,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1941,7 +1941,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1956,7 +1956,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1973,7 +1973,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -1989,7 +1989,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -2003,7 +2003,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -2017,7 +2017,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -2033,7 +2033,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -2048,7 +2048,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -2063,7 +2063,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -2078,7 +2078,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -2090,7 +2090,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -2105,7 +2105,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -2120,7 +2120,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -2136,7 +2136,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -2149,7 +2149,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -2162,7 +2162,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -2174,7 +2174,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -2186,7 +2186,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -2198,7 +2198,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -2211,7 +2211,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -2223,7 +2223,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -2235,7 +2235,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -2247,7 +2247,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -2259,7 +2259,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -2274,7 +2274,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -2289,7 +2289,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -2322,7 +2322,7 @@ expression: "&ir" sym: cycle_3, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -2337,7 +2337,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -2403,7 +2403,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -2415,7 +2415,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -2427,7 +2427,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -2440,7 +2440,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -2451,7 +2451,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -2465,7 +2465,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -2479,7 +2479,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -2495,7 +2495,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -2510,7 +2510,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -2526,7 +2526,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -2561,7 +2561,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -2576,7 +2576,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -2642,7 +2642,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -2654,7 +2654,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -2666,7 +2666,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -2679,7 +2679,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -2690,7 +2690,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -2704,7 +2704,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -2718,7 +2718,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -2734,7 +2734,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -2749,7 +2749,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -2765,7 +2765,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -2795,7 +2795,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -2807,7 +2807,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -2819,7 +2819,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -2832,7 +2832,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -2844,7 +2844,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -2859,7 +2859,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -2874,7 +2874,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -2890,7 +2890,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -2903,7 +2903,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -2916,7 +2916,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -2928,7 +2928,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -2940,7 +2940,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -2952,7 +2952,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -2965,7 +2965,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -2977,7 +2977,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -2989,7 +2989,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -3001,7 +3001,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -3013,7 +3013,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -3028,7 +3028,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -3043,7 +3043,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -3058,7 +3058,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -3075,7 +3075,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -3091,7 +3091,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -3105,7 +3105,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -3119,7 +3119,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -3135,7 +3135,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -3150,7 +3150,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -3165,7 +3165,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -3180,7 +3180,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -3192,7 +3192,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -3207,7 +3207,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -3222,7 +3222,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -3238,7 +3238,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -3251,7 +3251,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -3264,7 +3264,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -3276,7 +3276,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -3288,7 +3288,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -3300,7 +3300,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -3313,7 +3313,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -3325,7 +3325,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -3337,7 +3337,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -3349,7 +3349,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -3361,7 +3361,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -3376,7 +3376,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -3391,7 +3391,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -3406,7 +3406,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -3423,7 +3423,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -3439,7 +3439,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -3453,7 +3453,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -3467,7 +3467,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -3483,7 +3483,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -3498,7 +3498,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -3513,7 +3513,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -3528,7 +3528,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -3554,7 +3554,7 @@ expression: "&ir" sym: cycle_4, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -3569,7 +3569,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -3599,7 +3599,7 @@ expression: "&ir" sym: cycle_5, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3612,7 +3612,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3631,7 +3631,7 @@ expression: "&ir" inner: SingletonSource { value: { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; 0u32 }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3644,7 +3644,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3664,7 +3664,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: tick :: * ; let e__free = { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; () } ; [e__free] }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Optional { @@ -3674,7 +3674,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3687,7 +3687,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3700,7 +3700,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3713,7 +3713,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3726,7 +3726,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3739,7 +3739,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3752,7 +3752,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3783,7 +3783,7 @@ expression: "&ir" sym: cycle_6, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3797,7 +3797,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3811,7 +3811,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3825,7 +3825,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3853,7 +3853,7 @@ expression: "&ir" sym: cycle_5, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3866,7 +3866,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3885,7 +3885,7 @@ expression: "&ir" inner: SingletonSource { value: { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; 0u32 }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3898,7 +3898,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3918,7 +3918,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: tick :: * ; let e__free = { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; () } ; [e__free] }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Optional { @@ -3928,7 +3928,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3941,7 +3941,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3954,7 +3954,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3967,7 +3967,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3980,7 +3980,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -3993,7 +3993,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -4006,7 +4006,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -4021,7 +4021,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -4036,7 +4036,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -4051,7 +4051,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -4067,7 +4067,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -4119,7 +4119,7 @@ expression: "&ir" sym: cycle_3, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -4134,7 +4134,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -4200,7 +4200,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -4212,7 +4212,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -4224,7 +4224,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -4237,7 +4237,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -4248,7 +4248,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -4262,7 +4262,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -4276,7 +4276,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -4292,7 +4292,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -4307,7 +4307,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -4323,7 +4323,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -4358,7 +4358,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -4373,7 +4373,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -4439,7 +4439,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -4451,7 +4451,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -4463,7 +4463,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -4476,7 +4476,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -4487,7 +4487,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -4501,7 +4501,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -4515,7 +4515,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -4531,7 +4531,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -4546,7 +4546,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -4562,7 +4562,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -4592,7 +4592,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -4604,7 +4604,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -4616,7 +4616,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -4629,7 +4629,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -4641,7 +4641,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -4656,7 +4656,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -4671,7 +4671,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -4687,7 +4687,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -4700,7 +4700,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -4713,7 +4713,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -4725,7 +4725,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -4737,7 +4737,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -4749,7 +4749,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -4762,7 +4762,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -4774,7 +4774,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -4786,7 +4786,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -4798,7 +4798,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -4810,7 +4810,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -4825,7 +4825,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -4840,7 +4840,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -4855,7 +4855,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -4872,7 +4872,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -4888,7 +4888,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -4902,7 +4902,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -4916,7 +4916,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -4932,7 +4932,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -4947,7 +4947,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -4962,7 +4962,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -4977,7 +4977,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -4989,7 +4989,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -5004,7 +5004,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -5019,7 +5019,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -5035,7 +5035,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -5048,7 +5048,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -5061,7 +5061,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -5073,7 +5073,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -5085,7 +5085,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -5097,7 +5097,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -5110,7 +5110,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -5122,7 +5122,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -5134,7 +5134,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -5146,7 +5146,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -5158,7 +5158,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -5173,7 +5173,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -5188,7 +5188,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -5203,7 +5203,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -5220,7 +5220,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -5236,7 +5236,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -5250,7 +5250,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -5264,7 +5264,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -5280,7 +5280,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -5295,7 +5295,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -5310,7 +5310,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -5325,7 +5325,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -5337,7 +5337,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -5350,7 +5350,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -5362,7 +5362,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -5375,7 +5375,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5391,7 +5391,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5407,7 +5407,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5423,7 +5423,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5439,7 +5439,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5455,7 +5455,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5472,7 +5472,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5488,7 +5488,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5526,7 +5526,7 @@ expression: "&ir" sym: cycle_5, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5539,7 +5539,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5558,7 +5558,7 @@ expression: "&ir" inner: SingletonSource { value: { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; 0u32 }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5571,7 +5571,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5591,7 +5591,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: tick :: * ; let e__free = { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; () } ; [e__free] }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Optional { @@ -5601,7 +5601,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5614,7 +5614,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5627,7 +5627,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5640,7 +5640,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5653,7 +5653,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5666,7 +5666,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5679,7 +5679,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5694,7 +5694,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5709,7 +5709,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5724,7 +5724,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -5773,7 +5773,7 @@ expression: "&ir" sym: cycle_3, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -5788,7 +5788,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -5854,7 +5854,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -5866,7 +5866,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -5878,7 +5878,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -5891,7 +5891,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -5902,7 +5902,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -5916,7 +5916,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -5930,7 +5930,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -5946,7 +5946,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -5961,7 +5961,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -5977,7 +5977,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -6012,7 +6012,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -6027,7 +6027,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -6093,7 +6093,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -6105,7 +6105,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -6117,7 +6117,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -6130,7 +6130,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -6141,7 +6141,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -6155,7 +6155,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -6169,7 +6169,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -6185,7 +6185,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -6200,7 +6200,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -6216,7 +6216,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -6246,7 +6246,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -6258,7 +6258,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -6270,7 +6270,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -6283,7 +6283,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -6295,7 +6295,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -6310,7 +6310,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -6325,7 +6325,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -6341,7 +6341,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -6354,7 +6354,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -6367,7 +6367,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -6379,7 +6379,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -6391,7 +6391,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -6403,7 +6403,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -6416,7 +6416,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -6428,7 +6428,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -6440,7 +6440,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -6452,7 +6452,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -6464,7 +6464,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -6479,7 +6479,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -6494,7 +6494,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -6509,7 +6509,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -6526,7 +6526,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -6542,7 +6542,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -6556,7 +6556,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -6570,7 +6570,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -6586,7 +6586,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -6601,7 +6601,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -6616,7 +6616,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -6631,7 +6631,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -6643,7 +6643,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -6658,7 +6658,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -6673,7 +6673,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -6689,7 +6689,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -6702,7 +6702,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -6715,7 +6715,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -6727,7 +6727,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -6739,7 +6739,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -6751,7 +6751,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -6764,7 +6764,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -6776,7 +6776,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -6788,7 +6788,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -6800,7 +6800,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -6812,7 +6812,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -6827,7 +6827,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -6842,7 +6842,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -6857,7 +6857,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -6874,7 +6874,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -6890,7 +6890,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -6904,7 +6904,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -6918,7 +6918,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -6934,7 +6934,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -6949,7 +6949,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -6964,7 +6964,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -6979,7 +6979,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -6991,7 +6991,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -7004,7 +7004,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -7016,7 +7016,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -7029,7 +7029,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -7045,7 +7045,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -7061,7 +7061,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -7077,7 +7077,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -7093,7 +7093,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -7106,7 +7106,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -7118,7 +7118,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -7131,7 +7131,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -7183,7 +7183,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -7195,7 +7195,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -7207,7 +7207,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedStream { @@ -7220,7 +7220,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedSingleton { @@ -7231,7 +7231,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -7245,7 +7245,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -7259,7 +7259,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -7275,7 +7275,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -7291,7 +7291,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -7306,7 +7306,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -7319,7 +7319,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -7411,7 +7411,7 @@ expression: "&ir" sym: cycle_3, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -7426,7 +7426,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -7492,7 +7492,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -7504,7 +7504,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -7516,7 +7516,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -7529,7 +7529,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -7540,7 +7540,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -7554,7 +7554,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -7568,7 +7568,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -7584,7 +7584,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -7599,7 +7599,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -7615,7 +7615,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -7650,7 +7650,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -7665,7 +7665,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -7731,7 +7731,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -7743,7 +7743,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -7755,7 +7755,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -7768,7 +7768,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -7779,7 +7779,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -7793,7 +7793,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -7807,7 +7807,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -7823,7 +7823,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -7838,7 +7838,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -7854,7 +7854,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -7884,7 +7884,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -7896,7 +7896,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -7908,7 +7908,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -7921,7 +7921,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -7933,7 +7933,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -7948,7 +7948,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -7963,7 +7963,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -7979,7 +7979,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -7992,7 +7992,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -8005,7 +8005,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -8017,7 +8017,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -8029,7 +8029,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -8041,7 +8041,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -8054,7 +8054,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -8066,7 +8066,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -8078,7 +8078,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -8090,7 +8090,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -8102,7 +8102,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -8117,7 +8117,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -8132,7 +8132,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -8147,7 +8147,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -8164,7 +8164,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -8180,7 +8180,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -8194,7 +8194,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -8208,7 +8208,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -8224,7 +8224,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -8239,7 +8239,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -8254,7 +8254,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -8269,7 +8269,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -8281,7 +8281,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -8296,7 +8296,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -8311,7 +8311,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -8327,7 +8327,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -8340,7 +8340,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -8353,7 +8353,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -8365,7 +8365,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -8377,7 +8377,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -8389,7 +8389,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -8402,7 +8402,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -8414,7 +8414,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -8426,7 +8426,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -8438,7 +8438,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -8450,7 +8450,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -8465,7 +8465,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -8480,7 +8480,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -8495,7 +8495,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -8512,7 +8512,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -8528,7 +8528,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -8542,7 +8542,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -8556,7 +8556,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -8572,7 +8572,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -8587,7 +8587,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -8602,7 +8602,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -8617,7 +8617,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -8629,7 +8629,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -8642,7 +8642,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -8654,7 +8654,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -8667,7 +8667,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -8683,7 +8683,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -8699,7 +8699,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -8715,7 +8715,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -8730,7 +8730,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -8746,7 +8746,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -8761,7 +8761,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -8774,7 +8774,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -8789,7 +8789,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -8801,7 +8801,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -8819,7 +8819,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_secs (1) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -8831,7 +8831,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -8843,7 +8843,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -8855,7 +8855,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Singleton { @@ -8865,7 +8865,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Singleton { @@ -8875,7 +8875,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -8897,7 +8897,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -8909,7 +8909,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -8924,7 +8924,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -8937,7 +8937,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -8950,7 +8950,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -8963,7 +8963,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -8976,7 +8976,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -8991,7 +8991,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -9003,7 +9003,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -9015,7 +9015,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -9027,7 +9027,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedStream { @@ -9041,7 +9041,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedStream { @@ -9054,7 +9054,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedSingleton { @@ -9065,7 +9065,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedSingleton { @@ -9076,7 +9076,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -9090,7 +9090,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -9104,7 +9104,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -9120,7 +9120,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -9136,7 +9136,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -9151,7 +9151,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -9164,7 +9164,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -9177,7 +9177,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -9190,7 +9190,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -9203,7 +9203,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -9216,7 +9216,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -9231,7 +9231,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -9243,7 +9243,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 7, Process( 3, @@ -9267,7 +9267,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -9279,7 +9279,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 7, Process( 3, @@ -9294,7 +9294,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 7, Process( 3, @@ -9307,7 +9307,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 7, Process( 3, @@ -9320,7 +9320,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 7, Process( 3, @@ -9335,7 +9335,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 7, Process( 3, @@ -9350,7 +9350,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -9362,7 +9362,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -9375,7 +9375,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -9482,7 +9482,7 @@ expression: "&ir" sym: cycle_3, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -9497,7 +9497,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -9563,7 +9563,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -9575,7 +9575,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -9587,7 +9587,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -9600,7 +9600,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -9611,7 +9611,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -9625,7 +9625,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -9639,7 +9639,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -9655,7 +9655,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -9670,7 +9670,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -9686,7 +9686,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -9721,7 +9721,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -9736,7 +9736,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -9802,7 +9802,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -9814,7 +9814,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -9826,7 +9826,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -9839,7 +9839,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -9850,7 +9850,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -9864,7 +9864,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -9878,7 +9878,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -9894,7 +9894,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -9909,7 +9909,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -9925,7 +9925,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -9955,7 +9955,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -9967,7 +9967,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -9979,7 +9979,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -9992,7 +9992,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -10004,7 +10004,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -10019,7 +10019,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -10034,7 +10034,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -10050,7 +10050,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -10063,7 +10063,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -10076,7 +10076,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -10088,7 +10088,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -10100,7 +10100,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -10112,7 +10112,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -10125,7 +10125,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -10137,7 +10137,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -10149,7 +10149,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -10161,7 +10161,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -10173,7 +10173,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -10188,7 +10188,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -10203,7 +10203,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -10218,7 +10218,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -10235,7 +10235,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -10251,7 +10251,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -10265,7 +10265,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -10279,7 +10279,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -10295,7 +10295,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -10310,7 +10310,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -10325,7 +10325,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -10340,7 +10340,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -10352,7 +10352,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -10367,7 +10367,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -10382,7 +10382,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -10398,7 +10398,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -10411,7 +10411,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -10424,7 +10424,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -10436,7 +10436,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -10448,7 +10448,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -10460,7 +10460,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -10473,7 +10473,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -10485,7 +10485,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -10497,7 +10497,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -10509,7 +10509,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -10521,7 +10521,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -10536,7 +10536,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -10551,7 +10551,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -10566,7 +10566,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -10583,7 +10583,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -10599,7 +10599,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -10613,7 +10613,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -10627,7 +10627,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -10643,7 +10643,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -10658,7 +10658,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -10673,7 +10673,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -10688,7 +10688,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -10700,7 +10700,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -10713,7 +10713,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -10725,7 +10725,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -10738,7 +10738,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -10754,7 +10754,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -10770,7 +10770,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -10786,7 +10786,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -10801,7 +10801,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -10817,7 +10817,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -10832,7 +10832,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -10845,7 +10845,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -10860,7 +10860,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -10872,7 +10872,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -10890,7 +10890,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_secs (1) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -10902,7 +10902,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -10914,7 +10914,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -10926,7 +10926,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Singleton { @@ -10936,7 +10936,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Singleton { @@ -10946,7 +10946,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -10968,7 +10968,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -10980,7 +10980,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -10995,7 +10995,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -11008,7 +11008,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -11021,7 +11021,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -11034,7 +11034,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -11047,7 +11047,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -11062,7 +11062,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -11074,7 +11074,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -11086,7 +11086,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -11098,7 +11098,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedStream { @@ -11112,7 +11112,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedStream { @@ -11125,7 +11125,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedSingleton { @@ -11136,7 +11136,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedSingleton { @@ -11147,7 +11147,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 8, Process( 3, @@ -11161,7 +11161,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 8, Process( 3, @@ -11177,7 +11177,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 8, Process( 3, @@ -11192,7 +11192,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 8, Process( 3, @@ -11205,7 +11205,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Optional { @@ -11215,7 +11215,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 9, Process( 3, @@ -11237,7 +11237,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -11249,7 +11249,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 9, Process( 3, @@ -11264,7 +11264,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 9, Process( 3, @@ -11277,7 +11277,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 9, Process( 3, @@ -11290,7 +11290,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 9, Process( 3, @@ -11303,7 +11303,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 9, Process( 3, @@ -11316,7 +11316,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 9, Process( 3, @@ -11331,7 +11331,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -11343,7 +11343,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -11355,7 +11355,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -11393,7 +11393,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -11405,7 +11405,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -11417,7 +11417,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedStream { @@ -11430,7 +11430,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedSingleton { @@ -11441,7 +11441,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -11455,7 +11455,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -11469,7 +11469,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -11485,7 +11485,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -11501,7 +11501,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -11516,7 +11516,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -11529,7 +11529,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -11542,7 +11542,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -11555,7 +11555,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -11607,7 +11607,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -11619,7 +11619,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -11631,7 +11631,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedStream { @@ -11644,7 +11644,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedSingleton { @@ -11655,7 +11655,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -11669,7 +11669,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -11683,7 +11683,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -11699,7 +11699,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -11715,7 +11715,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -11730,7 +11730,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -11743,7 +11743,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -11835,7 +11835,7 @@ expression: "&ir" sym: cycle_3, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -11850,7 +11850,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -11916,7 +11916,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -11928,7 +11928,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -11940,7 +11940,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -11953,7 +11953,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -11964,7 +11964,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -11978,7 +11978,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -11992,7 +11992,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -12008,7 +12008,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -12023,7 +12023,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -12039,7 +12039,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -12074,7 +12074,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -12089,7 +12089,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -12155,7 +12155,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -12167,7 +12167,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -12179,7 +12179,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -12192,7 +12192,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -12203,7 +12203,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -12217,7 +12217,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -12231,7 +12231,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -12247,7 +12247,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -12262,7 +12262,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -12278,7 +12278,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -12308,7 +12308,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -12320,7 +12320,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -12332,7 +12332,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -12345,7 +12345,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -12357,7 +12357,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -12372,7 +12372,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -12387,7 +12387,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -12403,7 +12403,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -12416,7 +12416,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -12429,7 +12429,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -12441,7 +12441,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -12453,7 +12453,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -12465,7 +12465,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -12478,7 +12478,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -12490,7 +12490,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -12502,7 +12502,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -12514,7 +12514,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -12526,7 +12526,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -12541,7 +12541,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -12556,7 +12556,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -12571,7 +12571,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -12588,7 +12588,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -12604,7 +12604,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -12618,7 +12618,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -12632,7 +12632,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -12648,7 +12648,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -12663,7 +12663,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -12678,7 +12678,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -12693,7 +12693,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -12705,7 +12705,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -12720,7 +12720,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -12735,7 +12735,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -12751,7 +12751,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -12764,7 +12764,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -12777,7 +12777,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -12789,7 +12789,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -12801,7 +12801,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -12813,7 +12813,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -12826,7 +12826,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -12838,7 +12838,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -12850,7 +12850,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -12862,7 +12862,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -12874,7 +12874,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -12889,7 +12889,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -12904,7 +12904,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -12919,7 +12919,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -12936,7 +12936,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -12952,7 +12952,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -12966,7 +12966,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -12980,7 +12980,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -12996,7 +12996,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -13011,7 +13011,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -13026,7 +13026,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -13041,7 +13041,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -13053,7 +13053,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -13066,7 +13066,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -13078,7 +13078,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -13091,7 +13091,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -13107,7 +13107,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -13123,7 +13123,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -13139,7 +13139,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -13154,7 +13154,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -13170,7 +13170,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -13185,7 +13185,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -13198,7 +13198,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -13213,7 +13213,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -13225,7 +13225,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -13243,7 +13243,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_secs (1) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -13255,7 +13255,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -13267,7 +13267,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -13279,7 +13279,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Singleton { @@ -13289,7 +13289,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Singleton { @@ -13299,7 +13299,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -13321,7 +13321,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -13333,7 +13333,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -13348,7 +13348,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -13361,7 +13361,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -13374,7 +13374,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -13387,7 +13387,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -13400,7 +13400,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -13415,7 +13415,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -13427,7 +13427,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -13439,7 +13439,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -13451,7 +13451,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedStream { @@ -13465,7 +13465,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedStream { @@ -13478,7 +13478,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedSingleton { @@ -13489,7 +13489,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedSingleton { @@ -13500,7 +13500,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13514,7 +13514,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13528,7 +13528,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13544,7 +13544,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13560,7 +13560,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13575,7 +13575,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13588,7 +13588,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13601,7 +13601,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13614,7 +13614,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13627,7 +13627,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13640,7 +13640,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13653,7 +13653,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13669,7 +13669,7 @@ expression: "&ir" inner: SingletonSource { value: :: std :: option :: Option :: None, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13682,7 +13682,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13695,7 +13695,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13708,7 +13708,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13721,7 +13721,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13734,7 +13734,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13747,7 +13747,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13762,7 +13762,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -13777,7 +13777,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -13790,7 +13790,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -13869,7 +13869,7 @@ expression: "&ir" sym: cycle_6, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -13883,7 +13883,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -13897,7 +13897,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -13911,7 +13911,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -13927,7 +13927,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -13979,7 +13979,7 @@ expression: "&ir" sym: cycle_3, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -13994,7 +13994,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -14060,7 +14060,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -14072,7 +14072,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -14084,7 +14084,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -14097,7 +14097,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -14108,7 +14108,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -14122,7 +14122,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -14136,7 +14136,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -14152,7 +14152,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -14167,7 +14167,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -14183,7 +14183,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -14218,7 +14218,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -14233,7 +14233,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -14299,7 +14299,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -14311,7 +14311,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -14323,7 +14323,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -14336,7 +14336,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -14347,7 +14347,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -14361,7 +14361,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -14375,7 +14375,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -14391,7 +14391,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -14406,7 +14406,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -14422,7 +14422,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -14452,7 +14452,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -14464,7 +14464,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -14476,7 +14476,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -14489,7 +14489,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -14501,7 +14501,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -14516,7 +14516,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -14531,7 +14531,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -14547,7 +14547,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -14560,7 +14560,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -14573,7 +14573,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -14585,7 +14585,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -14597,7 +14597,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -14609,7 +14609,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -14622,7 +14622,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -14634,7 +14634,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -14646,7 +14646,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -14658,7 +14658,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -14670,7 +14670,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -14685,7 +14685,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -14700,7 +14700,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -14715,7 +14715,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -14732,7 +14732,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -14748,7 +14748,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -14762,7 +14762,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -14776,7 +14776,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -14792,7 +14792,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -14807,7 +14807,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -14822,7 +14822,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -14837,7 +14837,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -14849,7 +14849,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -14864,7 +14864,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -14879,7 +14879,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -14895,7 +14895,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -14908,7 +14908,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -14921,7 +14921,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -14933,7 +14933,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -14945,7 +14945,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -14957,7 +14957,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -14970,7 +14970,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -14982,7 +14982,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -14994,7 +14994,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -15006,7 +15006,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -15018,7 +15018,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -15033,7 +15033,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -15048,7 +15048,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -15063,7 +15063,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -15080,7 +15080,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -15096,7 +15096,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -15110,7 +15110,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -15124,7 +15124,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -15140,7 +15140,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -15155,7 +15155,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -15170,7 +15170,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -15185,7 +15185,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -15197,7 +15197,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -15210,7 +15210,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -15222,7 +15222,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -15235,7 +15235,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -15251,7 +15251,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -15267,7 +15267,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -15283,7 +15283,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -15299,7 +15299,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -15315,7 +15315,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -15330,7 +15330,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -15345,7 +15345,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -15361,7 +15361,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -15376,7 +15376,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -15391,7 +15391,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -15406,7 +15406,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -15419,7 +15419,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -15431,7 +15431,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Singleton { @@ -15441,7 +15441,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 10, Cluster( 2, @@ -15463,7 +15463,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -15475,7 +15475,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 10, Cluster( 2, @@ -15490,7 +15490,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 10, Cluster( 2, @@ -15503,7 +15503,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 10, Cluster( 2, @@ -15516,7 +15516,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 10, Cluster( 2, @@ -15529,7 +15529,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 10, Cluster( 2, @@ -15542,7 +15542,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 10, Cluster( 2, @@ -15557,7 +15557,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -15569,7 +15569,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -15581,7 +15581,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -15593,7 +15593,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -15605,7 +15605,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedStream { @@ -15618,7 +15618,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedStream { @@ -15632,7 +15632,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedStream { @@ -15645,7 +15645,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedSingleton { @@ -15656,7 +15656,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 11, Process( 3, @@ -15670,7 +15670,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 11, Process( 3, @@ -15686,7 +15686,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 11, Process( 3, @@ -15701,7 +15701,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 11, Process( 3, @@ -15714,7 +15714,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Optional { @@ -15724,7 +15724,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 12, Process( 3, @@ -15746,7 +15746,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -15758,7 +15758,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 12, Process( 3, @@ -15773,7 +15773,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 12, Process( 3, @@ -15786,7 +15786,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 12, Process( 3, @@ -15799,7 +15799,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 12, Process( 3, @@ -15812,7 +15812,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 12, Process( 3, @@ -15825,7 +15825,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 12, Process( 3, @@ -15840,7 +15840,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -15852,7 +15852,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -15864,7 +15864,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -15916,7 +15916,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -15928,7 +15928,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -15940,7 +15940,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedStream { @@ -15953,7 +15953,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedSingleton { @@ -15964,7 +15964,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -15978,7 +15978,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -15992,7 +15992,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -16008,7 +16008,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -16024,7 +16024,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -16039,7 +16039,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -16052,7 +16052,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -16144,7 +16144,7 @@ expression: "&ir" sym: cycle_3, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -16159,7 +16159,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -16225,7 +16225,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -16237,7 +16237,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -16249,7 +16249,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -16262,7 +16262,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -16273,7 +16273,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -16287,7 +16287,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -16301,7 +16301,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -16317,7 +16317,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -16332,7 +16332,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -16348,7 +16348,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -16383,7 +16383,7 @@ expression: "&ir" sym: cycle_1, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -16398,7 +16398,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -16464,7 +16464,7 @@ expression: "&ir" ), ), metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -16476,7 +16476,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -16488,7 +16488,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -16501,7 +16501,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedSingleton { @@ -16512,7 +16512,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -16526,7 +16526,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -16540,7 +16540,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -16556,7 +16556,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -16571,7 +16571,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -16587,7 +16587,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -16617,7 +16617,7 @@ expression: "&ir" sym: cycle_0, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -16629,7 +16629,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -16641,7 +16641,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -16654,7 +16654,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -16666,7 +16666,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -16681,7 +16681,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -16696,7 +16696,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 0, Process( 0, @@ -16712,7 +16712,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -16725,7 +16725,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -16738,7 +16738,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -16750,7 +16750,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -16762,7 +16762,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -16774,7 +16774,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -16787,7 +16787,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -16799,7 +16799,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -16811,7 +16811,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -16823,7 +16823,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -16835,7 +16835,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -16850,7 +16850,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -16865,7 +16865,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -16880,7 +16880,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -16897,7 +16897,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -16913,7 +16913,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -16927,7 +16927,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -16941,7 +16941,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -16957,7 +16957,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -16972,7 +16972,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -16987,7 +16987,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 1, Process( 0, @@ -17002,7 +17002,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -17014,7 +17014,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -17029,7 +17029,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -17044,7 +17044,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 2, Process( 0, @@ -17060,7 +17060,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -17073,7 +17073,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -17086,7 +17086,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 1, ), collection_kind: Stream { @@ -17098,7 +17098,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -17110,7 +17110,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -17122,7 +17122,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -17135,7 +17135,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -17147,7 +17147,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -17159,7 +17159,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -17171,7 +17171,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -17183,7 +17183,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -17198,7 +17198,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -17213,7 +17213,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -17228,7 +17228,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -17245,7 +17245,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -17261,7 +17261,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -17275,7 +17275,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -17289,7 +17289,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -17305,7 +17305,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -17320,7 +17320,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -17335,7 +17335,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 3, Process( 0, @@ -17350,7 +17350,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: Stream { @@ -17362,7 +17362,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 0, ), collection_kind: KeyedStream { @@ -17375,7 +17375,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -17387,7 +17387,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: KeyedStream { @@ -17400,7 +17400,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -17416,7 +17416,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -17432,7 +17432,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -17448,7 +17448,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -17463,7 +17463,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -17479,7 +17479,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -17494,7 +17494,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -17507,7 +17507,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 4, Cluster( 2, @@ -17522,7 +17522,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -17534,7 +17534,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -17552,7 +17552,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_secs (1) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -17564,7 +17564,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -17576,7 +17576,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -17588,7 +17588,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Singleton { @@ -17598,7 +17598,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Singleton { @@ -17608,7 +17608,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -17630,7 +17630,7 @@ expression: "&ir" { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, ), metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -17642,7 +17642,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -17657,7 +17657,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -17670,7 +17670,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -17683,7 +17683,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -17696,7 +17696,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -17709,7 +17709,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 6, Cluster( 2, @@ -17724,7 +17724,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -17736,7 +17736,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Cluster( + location_id: Cluster( 2, ), collection_kind: Stream { @@ -17748,7 +17748,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -17760,7 +17760,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedStream { @@ -17774,7 +17774,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedStream { @@ -17787,7 +17787,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedSingleton { @@ -17798,7 +17798,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: KeyedSingleton { @@ -17809,7 +17809,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -17823,7 +17823,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -17837,7 +17837,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -17853,7 +17853,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -17869,7 +17869,7 @@ expression: "&ir" }, trusted: true, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -17884,7 +17884,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -17897,7 +17897,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -17910,7 +17910,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -17923,7 +17923,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -17936,7 +17936,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -17949,7 +17949,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -17962,7 +17962,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -17978,7 +17978,7 @@ expression: "&ir" inner: SingletonSource { value: :: std :: option :: Option :: None, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -17991,7 +17991,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -18004,7 +18004,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -18017,7 +18017,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -18030,7 +18030,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -18043,7 +18043,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -18056,7 +18056,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -18071,7 +18071,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Tick( + location_id: Tick( 5, Process( 3, @@ -18086,7 +18086,7 @@ expression: "&ir" }, }, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { @@ -18099,7 +18099,7 @@ expression: "&ir" }, trusted: false, metadata: HydroIrMetadata { - location_kind: Process( + location_id: Process( 3, ), collection_kind: Stream { diff --git a/hydro_optimize/src/tests/two_pc.rs b/hydro_optimize/src/tests/two_pc.rs index 378d6fa..ce1fd12 100644 --- a/hydro_optimize/src/tests/two_pc.rs +++ b/hydro_optimize/src/tests/two_pc.rs @@ -1,4 +1,4 @@ -tuse std::collections::{BTreeMap, HashMap}; +use std::collections::{BTreeMap, HashMap}; use hydro_build_utils::insta; use hydro_lang::compile::ir::deep_clone; @@ -33,7 +33,7 @@ fn create_two_pc<'a>( #[test] fn two_pc_partition_coordinator() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let coordinator = builder.process(); let partitioned_coordinator = builder.cluster::<()>(); let participants = builder.cluster(); @@ -79,8 +79,8 @@ fn two_pc_partition_coordinator() { let coordinator_partitioner = Partitioner { nodes_to_partition: coordinator_nodes_to_partition, num_partitions: 3, - location_id: coordinator.id().raw_id(), - new_cluster_id: Some(partitioned_coordinator.id().raw_id()), + location_id: coordinator.id().key(), + new_cluster_id: Some(partitioned_coordinator.id().key()), }; partition(&mut ir, &coordinator_partitioner); @@ -89,7 +89,7 @@ fn two_pc_partition_coordinator() { #[test] fn two_pc_partition_participant() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let coordinator = builder.process(); let participants = builder.cluster(); let clients = builder.cluster(); @@ -129,7 +129,7 @@ fn two_pc_partition_participant() { let participant_partitioner = Partitioner { nodes_to_partition: participant_nodes_to_partition, num_partitions: 3, - location_id: participants.id().raw_id(), + location_id: participants.id().key(), new_cluster_id: None, }; partition(&mut ir, &participant_partitioner); From 78e0e0c6a8e0d43f0e3e70fe2ff8cfe6af012113 Mon Sep 17 00:00:00 2001 From: David Chu Date: Wed, 28 Jan 2026 00:57:46 +0000 Subject: [PATCH 16/35] Attempt to use Sidecar API, untested --- hydro_optimize/src/deploy_and_analyze.rs | 42 +++++++++++++++++++++++- 1 file changed, 41 insertions(+), 1 deletion(-) diff --git a/hydro_optimize/src/deploy_and_analyze.rs b/hydro_optimize/src/deploy_and_analyze.rs index 9ea6ea0..3a82663 100644 --- a/hydro_optimize/src/deploy_and_analyze.rs +++ b/hydro_optimize/src/deploy_and_analyze.rs @@ -11,6 +11,7 @@ use hydro_lang::deploy::HydroDeploy; use hydro_lang::deploy::deploy_graph::DeployCrateWrapper; use hydro_lang::location::dynamic::LocationId; use hydro_lang::prelude::FlowBuilder; +use hydro_lang::telemetry::Sidecar; use tokio::sync::mpsc::UnboundedReceiver; use crate::decouple_analysis::decouple_analysis; @@ -133,6 +134,40 @@ async fn track_cluster_usage_cardinality( (usage_out, cardinality_out) } +struct ScriptSidecar { + script: String, +} + +impl Sidecar for ScriptSidecar { + fn to_expr( + &self, + _flow_name: &str, + location_key: hydro_lang::location::LocationKey, + _location_type: hydro_lang::location::LocationType, + _location_name: &str, + _dfir_ident: &syn::Ident, + ) -> syn::Expr { + let script = &self.script; + let location_key_str = format!("{:?}", location_key); + + syn::parse_quote! { + async { + let output = tokio::process::Command::new("sh") + .arg("-c") + .arg(#script) + .output() + .await + .expect(&format!("Failed to run sidecar script: {}", #script)); + + let stdout = String::from_utf8_lossy(&output.stdout); + for line in stdout.lines() { + println!("{}: {}", #location_key_str, line); + } + } + } + } +} + /// TODO: Return type should be changed to also include Partitioner #[expect(clippy::too_many_arguments, reason = "Optimizer internal function")] #[expect( @@ -182,7 +217,12 @@ pub async fn deploy_and_analyze<'a>( reusable_hosts.get_process_hosts(deployment, name.clone()), ); } - let nodes = deployable.deploy(deployment); + let network_sidecar = ScriptSidecar { + script: "sar -n DEV 1".to_string(), + }; + let nodes = deployable + .with_sidecar_all(&network_sidecar) // Measure network usage + .deploy(deployment); deployment.deploy().await.unwrap(); let (mut usage_out, mut cardinality_out) = track_cluster_usage_cardinality(&nodes).await; From 8188fe9e81f71fec0b05a0fe485d420c79415efe Mon Sep 17 00:00:00 2001 From: David Chu Date: Wed, 28 Jan 2026 11:35:12 -0800 Subject: [PATCH 17/35] Merge with_cluster_erased, WIP cleaning up optimization functions --- Cargo.lock | 36 ++--- Cargo.toml | 14 +- hydro_optimize/src/decouple_analysis.rs | 37 +++--- hydro_optimize/src/decoupler.rs | 57 +++++--- hydro_optimize/src/deploy_and_analyze.rs | 125 ++++++++++++------ hydro_optimize/src/parse_results.rs | 4 +- hydro_optimize/src/rewrites.rs | 2 +- .../examples/benchmark_paxos.rs | 14 +- .../examples/decouple_compute_pi.rs | 97 -------------- .../examples/network_calibrator.rs | 48 +++---- .../examples/partition_simple_cluster.rs | 80 ----------- .../examples/partition_two_pc.rs | 12 +- .../examples/perf_paxos.rs | 64 ++++----- hydro_optimize_examples/src/lobsters.rs | 57 ++++---- hydro_optimize_examples/src/lock_server.rs | 115 ++++++++-------- .../src/network_calibrator.rs | 6 +- 16 files changed, 323 insertions(+), 445 deletions(-) delete mode 100644 hydro_optimize_examples/examples/decouple_compute_pi.rs delete mode 100644 hydro_optimize_examples/examples/partition_simple_cluster.rs diff --git a/Cargo.lock b/Cargo.lock index 1e65e2a..2b7f551 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -895,7 +895,7 @@ dependencies = [ [[package]] name = "copy_span" version = "0.1.0" -source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" dependencies = [ "proc-macro2", "syn", @@ -1114,7 +1114,7 @@ dependencies = [ [[package]] name = "dfir_lang" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" dependencies = [ "auto_impl", "documented", @@ -1780,7 +1780,7 @@ checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" [[package]] name = "hydro_build_utils" version = "0.0.1" -source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" dependencies = [ "insta", "rustc_version", @@ -1789,7 +1789,7 @@ dependencies = [ [[package]] name = "hydro_deploy" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" dependencies = [ "anyhow", "append-only-vec", @@ -1825,7 +1825,7 @@ dependencies = [ [[package]] name = "hydro_deploy_integration" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" dependencies = [ "async-recursion", "async-trait", @@ -1843,7 +1843,7 @@ dependencies = [ [[package]] name = "hydro_lang" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" dependencies = [ "auto_impl", "backtrace", @@ -1934,7 +1934,7 @@ dependencies = [ [[package]] name = "hydro_std" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" dependencies = [ "hdrhistogram", "hydro_lang", @@ -1946,7 +1946,7 @@ dependencies = [ [[package]] name = "hydro_test" version = "0.0.0" -source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" dependencies = [ "bytes", "colored", @@ -1957,10 +1957,12 @@ dependencies = [ "palette", "rand 0.8.5", "serde", + "serde_json", "stageleft", "stageleft_tool", "tokio", "tokio-stream", + "tokio-util", ] [[package]] @@ -2027,9 +2029,9 @@ dependencies = [ [[package]] name = "iana-time-zone" -version = "0.1.64" +version = "0.1.65" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "33e57f83510bb73707521ebaffa789ec8caf86f9657cad665b092b581d40e9fb" +checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470" dependencies = [ "android_system_properties", "core-foundation-sys", @@ -2154,7 +2156,7 @@ dependencies = [ [[package]] name = "include_mdtests" version = "0.0.0" -source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" dependencies = [ "glob", "proc-macro2", @@ -4003,7 +4005,7 @@ checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa" [[package]] name = "sinktools" version = "0.0.1" -source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" dependencies = [ "futures-util", "pin-project-lite", @@ -4787,7 +4789,7 @@ checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" [[package]] name = "variadics" version = "0.0.10" -source = "git+https://github.com/hydro-project/hydro.git#6bf5126e46019dcfafee44afa8e18b78d0a49b0f" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" dependencies = [ "hashbrown 0.14.5", "hydro_build_utils", @@ -5427,18 +5429,18 @@ dependencies = [ [[package]] name = "zerocopy" -version = "0.8.34" +version = "0.8.35" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "71ddd76bcebeed25db614f82bf31a9f4222d3fbba300e6fb6c00afa26cbd4d9d" +checksum = "fdea86ddd5568519879b8187e1cf04e24fce28f7fe046ceecbce472ff19a2572" dependencies = [ "zerocopy-derive", ] [[package]] name = "zerocopy-derive" -version = "0.8.34" +version = "0.8.35" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d8187381b52e32220d50b255276aa16a084ec0a9017a0ca2152a1f55c539758d" +checksum = "0c15e1b46eff7c6c91195752e0eeed8ef040e391cdece7c25376957d5f15df22" dependencies = [ "proc-macro2", "quote", diff --git a/Cargo.toml b/Cargo.toml index e10b2b7..e88fcab 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,13 +8,13 @@ members = [ resolver = "2" [workspace.dependencies] -hydro_lang = { version = "0.15.0", git = "https://github.com/hydro-project/hydro.git" } -hydro_std = { version = "0.15.0", git = "https://github.com/hydro-project/hydro.git" } -hydro_test = { version = "0.0.0", git = "https://github.com/hydro-project/hydro.git" } -dfir_lang = { version = "0.15.0", git = "https://github.com/hydro-project/hydro.git" } -hydro_build_utils = { version = "0.0.1", git = "https://github.com/hydro-project/hydro.git" } -hydro_deploy = { version = "0.15.0", git = "https://github.com/hydro-project/hydro.git", features = ["profile-folding"] } -include_mdtests = { version = "0.0.0", git = "https://github.com/hydro-project/hydro.git" } +hydro_lang = { version = "0.15.0", git = "https://github.com/hydro-project/hydro.git", branch = "david-fixes" } +hydro_std = { version = "0.15.0", git = "https://github.com/hydro-project/hydro.git", branch = "david-fixes" } +hydro_test = { version = "0.0.0", git = "https://github.com/hydro-project/hydro.git", branch = "david-fixes" } +dfir_lang = { version = "0.15.0", git = "https://github.com/hydro-project/hydro.git", branch = "david-fixes" } +hydro_build_utils = { version = "0.0.1", git = "https://github.com/hydro-project/hydro.git", branch = "david-fixes" } +hydro_deploy = { version = "0.15.0", git = "https://github.com/hydro-project/hydro.git", branch = "david-fixes", features = ["profile-folding"] } +include_mdtests = { version = "0.0.0", git = "https://github.com/hydro-project/hydro.git", branch = "david-fixes" } serde = { version = "1.0.197", features = ["derive"] } stageleft = "0.13.0" stageleft_tool = "0.13.0" diff --git a/hydro_optimize/src/decouple_analysis.rs b/hydro_optimize/src/decouple_analysis.rs index eeea002..0c6a651 100644 --- a/hydro_optimize/src/decouple_analysis.rs +++ b/hydro_optimize/src/decouple_analysis.rs @@ -1,6 +1,7 @@ use std::cell::RefCell; use std::collections::HashMap; +use crate::decoupler::DecoupleDecision; use crate::rewrites::op_id_to_inputs; use good_lp::solvers::highs::HighsSolution; use good_lp::{ @@ -387,7 +388,7 @@ pub(crate) fn decouple_analysis( send_overhead: f64, recv_overhead: f64, cycle_source_to_sink_input: &HashMap, -) -> (Vec, Vec, Vec) { +) -> DecoupleDecision { let model_metadata = RefCell::new(ModelMetadata { cluster_to_decouple: cluster_to_decouple.clone(), decoupling_send_overhead: send_overhead, @@ -401,8 +402,11 @@ pub(crate) fn decouple_analysis( tee_inner_to_decoupled_vars: HashMap::new(), network_ids: HashMap::new(), }); - let op_id_to_inputs = - op_id_to_inputs(ir, Some(&cluster_to_decouple.key()), cycle_source_to_sink_input); + let op_id_to_inputs = op_id_to_inputs( + ir, + Some(&cluster_to_decouple.key()), + cycle_source_to_sink_input, + ); traverse_dfir::( ir, @@ -433,9 +437,7 @@ pub(crate) fn decouple_analysis( let mut orig_machine = vec![]; let mut decoupled_machine = vec![]; - let mut orig_to_decoupled = vec![]; - let mut decoupled_to_orig = vec![]; - let mut place_on_decoupled = vec![]; + let mut decision = DecoupleDecision::default(); for (op_id, inputs) in op_id_to_inputs { if let Some(op_var) = op_id_to_var.get(&op_id) { @@ -457,10 +459,10 @@ pub(crate) fn decouple_analysis( // Figure out if we should insert Network nodes match (input_unwrapped, op_value) { (0.0, 1.0) => { - orig_to_decoupled.push(op_id); + decision.output_to_decoupled_machine_after.push(op_id); } (1.0, 0.0) => { - decoupled_to_orig.push(op_id); + decision.output_to_original_machine_after.push(op_id); } _ => {} } @@ -477,7 +479,7 @@ pub(crate) fn decouple_analysis( decoupled_machine.push(op_id); // Don't modify the destination if we're sending to someone else if !network_type.is_some_and(|t| *t == NetworkType::Send) { - place_on_decoupled.push(op_id); + decision.place_on_decoupled_machine.push(op_id); } } } @@ -488,18 +490,21 @@ pub(crate) fn decouple_analysis( decoupled_machine.sort(); println!("Original: {:?}", orig_machine); println!("Decoupling: {:?}", decoupled_machine); - orig_to_decoupled.sort(); - decoupled_to_orig.sort(); - place_on_decoupled.sort(); + decision.output_to_decoupled_machine_after.sort(); + decision.output_to_original_machine_after.sort(); + decision.place_on_decoupled_machine.sort(); println!( "Original outputting to decoupled after: {:?}", - orig_to_decoupled + decision.output_to_decoupled_machine_after ); println!( "Decoupled outputting to original after: {:?}", - decoupled_to_orig + decision.output_to_original_machine_after + ); + println!( + "Placing on decoupled: {:?}", + decision.place_on_decoupled_machine ); - println!("Placing on decoupled: {:?}", place_on_decoupled); - (orig_to_decoupled, decoupled_to_orig, place_on_decoupled) + decision } diff --git a/hydro_optimize/src/decoupler.rs b/hydro_optimize/src/decoupler.rs index 9be87e2..ada5f28 100644 --- a/hydro_optimize/src/decoupler.rs +++ b/hydro_optimize/src/decoupler.rs @@ -20,11 +20,16 @@ use crate::rewrites::{ prepend_member_id_to_collection_kind, serialize_bincode_with_type, tee_to_inner_id, }; -#[derive(Clone, Serialize, Deserialize)] -pub struct Decoupler { +#[derive(Clone, Serialize, Deserialize, Default)] +pub struct DecoupleDecision { pub output_to_decoupled_machine_after: Vec, /* The output of the operator at this index should be sent to the decoupled machine */ pub output_to_original_machine_after: Vec, /* The output of the operator at this index should be sent to the original machine */ pub place_on_decoupled_machine: Vec, /* This operator should be placed on the decoupled machine. Only for sources */ +} + +#[derive(Clone, Serialize, Deserialize)] +pub struct Decoupler { + pub decision: DecoupleDecision, pub orig_location: LocationId, pub decoupled_location: LocationId, } @@ -151,7 +156,11 @@ fn decouple_node( tee_to_inner_id_before_rewrites: &HashMap, ) { // Replace location of sources, if necessary - if decoupler.place_on_decoupled_machine.contains(next_stmt_id) { + if decoupler + .decision + .place_on_decoupled_machine + .contains(next_stmt_id) + { match node { HydroNode::Source { metadata, .. } | HydroNode::SingletonSource { metadata, .. } @@ -178,11 +187,13 @@ fn decouple_node( // Otherwise, replace where the outputs go let new_location = if decoupler + .decision .output_to_decoupled_machine_after .contains(next_stmt_id) { &decoupler.decoupled_location } else if decoupler + .decision .output_to_original_machine_after .contains(next_stmt_id) { @@ -311,7 +322,7 @@ mod tests { use stageleft::q; use crate::debug::{name_to_id_map, print_id}; - use crate::decoupler::{Decoupler, decouple}; + use crate::decoupler::{DecoupleDecision, Decoupler, decouple}; use crate::repair::inject_id; fn decouple_mini_program<'a>( @@ -347,24 +358,26 @@ mod tests { // Convert named nodes to IDs, accounting for the offset let name_to_id = name_to_id_map(ir); let decoupler = Decoupler { - output_to_decoupled_machine_after: output_to_decoupled_machine_after - .into_iter() - .map(|(name, offset)| { - (name_to_id.get(name).cloned().unwrap() as i32 + offset) as usize - }) - .collect(), - output_to_original_machine_after: output_to_original_machine_after - .into_iter() - .map(|(name, offset)| { - (name_to_id.get(name).cloned().unwrap() as i32 + offset) as usize - }) - .collect(), - place_on_decoupled_machine: place_on_decoupled_machine - .into_iter() - .map(|(name, offset)| { - (name_to_id.get(name).cloned().unwrap() as i32 + offset) as usize - }) - .collect(), + decision: DecoupleDecision { + output_to_decoupled_machine_after: output_to_decoupled_machine_after + .into_iter() + .map(|(name, offset)| { + (name_to_id.get(name).cloned().unwrap() as i32 + offset) as usize + }) + .collect(), + output_to_original_machine_after: output_to_original_machine_after + .into_iter() + .map(|(name, offset)| { + (name_to_id.get(name).cloned().unwrap() as i32 + offset) as usize + }) + .collect(), + place_on_decoupled_machine: place_on_decoupled_machine + .into_iter() + .map(|(name, offset)| { + (name_to_id.get(name).cloned().unwrap() as i32 + offset) as usize + }) + .collect(), + }, decoupled_location: decoupled_cluster.id().clone(), orig_location: send_cluster.id().clone(), }; diff --git a/hydro_optimize/src/deploy_and_analyze.rs b/hydro_optimize/src/deploy_and_analyze.rs index 3a82663..5c39b2f 100644 --- a/hydro_optimize/src/deploy_and_analyze.rs +++ b/hydro_optimize/src/deploy_and_analyze.rs @@ -3,19 +3,19 @@ use std::collections::HashMap; use std::time::Duration; use hydro_deploy::Deployment; -use hydro_lang::compile::builder::RewriteIrFlowBuilder; use hydro_lang::compile::built::BuiltFlow; use hydro_lang::compile::deploy::DeployResult; use hydro_lang::compile::ir::{HydroNode, HydroRoot, deep_clone, traverse_dfir}; use hydro_lang::deploy::HydroDeploy; use hydro_lang::deploy::deploy_graph::DeployCrateWrapper; +use hydro_lang::location::LocationKey; use hydro_lang::location::dynamic::LocationId; use hydro_lang::prelude::FlowBuilder; use hydro_lang::telemetry::Sidecar; use tokio::sync::mpsc::UnboundedReceiver; use crate::decouple_analysis::decouple_analysis; -use crate::decoupler::Decoupler; +use crate::decoupler::{self, Decoupler}; use crate::deploy::ReusableHosts; use crate::parse_results::{ MultiRunMetadata, analyze_cluster_results, analyze_send_recv_overheads, @@ -168,33 +168,64 @@ impl Sidecar for ScriptSidecar { } } -/// TODO: Return type should be changed to also include Partitioner +pub struct Optimizations { + decoupling: bool, + partitioning: bool, + iterations: usize, // Performs no optimizations if iterations = 0 +} + +impl Optimizations { + pub fn new() -> Self { + Self { + decoupling: false, + partitioning: false, + iterations: 0, + } + } + + pub fn with_decoupling(mut self) -> Self { + self.decoupling = true; + if self.iterations == 0 { + self.iterations = 1; + } + self + } + + pub fn with_partitioning(mut self) -> Self { + self.partitioning = true; + if self.iterations == 0 { + self.iterations = 1; + } + self + } + + pub fn with_iterations(mut self, iterations: usize) -> Self { + self.iterations = iterations; + self + } +} + #[expect(clippy::too_many_arguments, reason = "Optimizer internal function")] #[expect( clippy::await_holding_refcell_ref, reason = "Await function needs to write to data in RefCell" )] -pub async fn deploy_and_analyze<'a>( +pub async fn deploy_and_optimize<'a>( reusable_hosts: &mut ReusableHosts, deployment: &mut Deployment, builder: BuiltFlow<'a>, - clusters: &Vec<(usize, String, usize)>, - processes: &Vec<(usize, String)>, - exclude_from_decoupling: Vec, + clusters: &mut Vec<(LocationKey, String, usize)>, + processes: &Vec<(LocationKey, String)>, + exclude_from_rewrites: Vec, + optimizations: Optimizations, num_seconds: Option, multi_run_metadata: &RefCell, iteration: usize, // Starts at 0, how many times this function has been called -) -> ( - RewriteIrFlowBuilder<'a>, - Vec, - Decoupler, - String, - usize, -) { +) -> FlowBuilder<'a> { let counter_output_duration = syn::parse_quote!(std::time::Duration::from_secs(1)); // Rewrite with counter tracking - let rewritten_ir_builder = FlowBuilder::rewritten_ir_builder(&builder); + let mut post_rewrite_builder = FlowBuilder::from_built(&builder); let optimized = builder.optimize_with(|leaf| { inject_id(leaf); insert_counter(leaf, counter_output_duration); @@ -204,16 +235,14 @@ pub async fn deploy_and_analyze<'a>( // Insert all clusters & processes let mut deployable = optimized.into_deploy(); for (cluster_id, name, num_hosts) in clusters { - deployable = deployable.with_cluster_id_name( + deployable = deployable.with_cluster_erased( *cluster_id, - name.clone(), reusable_hosts.get_cluster_hosts(deployment, name.clone(), *num_hosts), ); } for (process_id, name) in processes { - deployable = deployable.with_process_id_name( + deployable = deployable.with_process_erased( *process_id, - name.clone(), reusable_hosts.get_process_hosts(deployment, name.clone()), ); } @@ -256,7 +285,7 @@ pub async fn deploy_and_analyze<'a>( &mut usage_out, &mut cardinality_out, run_metadata, - exclude_from_decoupling, + exclude_from_rewrites, ) .await; // Remove HydroNode::Counter (since we don't want to consider decoupling those) @@ -280,27 +309,41 @@ pub async fn deploy_and_analyze<'a>( std::mem::drop(mut_multi_run_metadata); // Release borrow compare_expected_performance(&mut ir, multi_run_metadata, iteration); - let (orig_to_decoupled, decoupled_to_orig, place_on_decoupled) = decouple_analysis( - &mut ir, - &bottleneck, - send_overhead, - recv_overhead, - &cycle_source_to_sink_input, - ); + if optimizations.decoupling { + let decision = decouple_analysis( + &mut ir, + &bottleneck, + send_overhead, + recv_overhead, + &cycle_source_to_sink_input, + ); - // TODO: Save decoupling decision to file + // Apply decoupling + let mut decoupled_cluster = None; + let new_cluster = post_rewrite_builder.cluster::<()>(); + let decouple_with_location = Decoupler { + decision, + orig_location: bottleneck, + decoupled_location: new_cluster.id().clone(), + }; + decoupler::decouple( + &mut ir, + &decouple_with_location, + &multi_run_metadata, + iteration, + ); + post_rewrite_builder.replace_ir(ir); + decoupled_cluster = Some(new_cluster); - ( - rewritten_ir_builder, - ir, - Decoupler { - output_to_decoupled_machine_after: orig_to_decoupled, - output_to_original_machine_after: decoupled_to_orig, - place_on_decoupled_machine: place_on_decoupled, - orig_location: bottleneck.clone(), - decoupled_location: LocationId::Process(0), // Placeholder, must replace - }, - bottleneck_name, - bottleneck_num_nodes, - ) + if let Some(new_cluster) = decoupled_cluster { + clusters.push(( + new_cluster.id().key(), + format!("{}-decouple-{}", bottleneck_name, iteration), + bottleneck_num_nodes, + )); + } + // TODO: Save decoupling decision to file + } + + post_rewrite_builder } diff --git a/hydro_optimize/src/parse_results.rs b/hydro_optimize/src/parse_results.rs index 52d9a7d..1969264 100644 --- a/hydro_optimize/src/parse_results.rs +++ b/hydro_optimize/src/parse_results.rs @@ -228,7 +228,7 @@ pub async fn analyze_cluster_results( usage_out: &mut HashMap<(LocationId, String, usize), UnboundedReceiver>, cardinality_out: &mut HashMap<(LocationId, String, usize), UnboundedReceiver>, run_metadata: &mut RunMetadata, - exclude_from_decoupling: Vec, + exclude: Vec, ) -> (LocationId, String, usize) { let mut max_usage_cluster_id = None; let mut max_usage_cluster_size = 0; @@ -273,7 +273,7 @@ pub async fn analyze_cluster_results( .insert(id.clone(), unidentified_perf); // Update cluster with max usage - if max_usage_overall < usage && !exclude_from_decoupling.contains(&name) { + if max_usage_overall < usage && !exclude.contains(&name) { max_usage_cluster_id = Some(id); max_usage_cluster_name = name.clone(); max_usage_cluster_size = cluster.members().len(); diff --git a/hydro_optimize/src/rewrites.rs b/hydro_optimize/src/rewrites.rs index 33a9b78..507e268 100644 --- a/hydro_optimize/src/rewrites.rs +++ b/hydro_optimize/src/rewrites.rs @@ -1,7 +1,7 @@ use std::cell::RefCell; use std::collections::HashMap; -use hydro_lang::compile::builder::{FlowBuilder, RewriteIrFlowBuilder}; +use hydro_lang::compile::builder::FlowBuilder; use hydro_lang::compile::ir::{ BoundKind, CollectionKind, DebugType, HydroIrMetadata, HydroNode, HydroRoot, KeyedSingletonBoundKind, StreamOrder, StreamRetry, deep_clone, traverse_dfir, diff --git a/hydro_optimize_examples/examples/benchmark_paxos.rs b/hydro_optimize_examples/examples/benchmark_paxos.rs index 7835cdc..d294653 100644 --- a/hydro_optimize_examples/examples/benchmark_paxos.rs +++ b/hydro_optimize_examples/examples/benchmark_paxos.rs @@ -4,7 +4,7 @@ use clap::{ArgAction, Parser}; use hydro_deploy::Deployment; use hydro_lang::location::Location; use hydro_optimize::deploy::{HostType, ReusableHosts}; -use hydro_optimize::deploy_and_analyze::deploy_and_analyze; +use hydro_optimize::deploy_and_analyze::deploy_and_optimize; use hydro_test::cluster::kv_replica::Replica; use hydro_test::cluster::paxos::{Acceptor, CorePaxos, PaxosConfig, Proposer}; use hydro_test::cluster::paxos_bench::{Aggregator, Client}; @@ -100,32 +100,32 @@ async fn main() { let clusters = vec![ ( - proposers.id().raw_id(), + proposers.id().key(), std::any::type_name::().to_string(), f + 1, ), ( - acceptors.id().raw_id(), + acceptors.id().key(), std::any::type_name::().to_string(), 2 * f + 1, ), ( - clients.id().raw_id(), + clients.id().key(), std::any::type_name::().to_string(), *num_clients, ), ( - replicas.id().raw_id(), + replicas.id().key(), std::any::type_name::().to_string(), f + 1, ), ]; let processes = vec![( - client_aggregator.id().raw_id(), + client_aggregator.id().key(), std::any::type_name::().to_string(), )]; - let (rewritten_ir_builder, ir, _, _, _) = deploy_and_analyze( + let (rewritten_ir_builder, ir, _, _, _) = deploy_and_optimize( &mut reusable_hosts, &mut deployment, builder.finalize(), diff --git a/hydro_optimize_examples/examples/decouple_compute_pi.rs b/hydro_optimize_examples/examples/decouple_compute_pi.rs deleted file mode 100644 index 9ad4c73..0000000 --- a/hydro_optimize_examples/examples/decouple_compute_pi.rs +++ /dev/null @@ -1,97 +0,0 @@ -use std::cell::RefCell; - -use clap::{ArgAction, Parser}; -use hydro_deploy::Deployment; -use hydro_lang::location::Location; -use hydro_lang::viz::config::GraphConfig; -use hydro_optimize::debug; -use hydro_optimize::decoupler::{self, Decoupler}; -use hydro_optimize::deploy::{HostType, ReusableHosts}; -use hydro_optimize::deploy_and_analyze::deploy_and_analyze; -use hydro_test::cluster::compute_pi::{Leader, Worker}; - -#[derive(Parser, Debug)] -#[command(author, version, about, long_about = None, group( - clap::ArgGroup::new("cloud") - .args(&["gcp", "aws"]) - .multiple(false) -))] -struct Args { - #[command(flatten)] - graph: GraphConfig, - - /// Use Gcp for deployment (provide project name) - #[arg(long)] - gcp: Option, - - /// Use Aws, make sure credentials are set up - #[arg(long, action = ArgAction::SetTrue)] - aws: bool, -} - -struct DecoupledCluster {} - -#[tokio::main] -async fn main() { - let args = Args::parse(); - let mut deployment = Deployment::new(); - - let host_type: HostType = if let Some(project) = args.gcp { - HostType::Gcp { project } - } else if args.aws { - HostType::Aws - } else { - HostType::Localhost - }; - - let mut reusable_hosts = ReusableHosts::new(host_type); - - let builder = hydro_lang::compile::builder::FlowBuilder::new(); - let num_cluster_nodes = 8; - let (cluster, leader) = hydro_test::cluster::compute_pi::compute_pi(&builder, 8192); - - let clusters = vec![( - cluster.id().raw_id(), - std::any::type_name::().to_string(), - num_cluster_nodes, - )]; - let decoupled_cluster = builder.cluster::(); - let processes = vec![( - leader.id().raw_id(), - std::any::type_name::().to_string(), - )]; - - let decoupler = Decoupler { - // Decouple between these operators: - // .map(q!(|_| rand::random::<(f64, f64)>())) - // .map(q!(|(x, y)| x * x + y * y < 1.0)) - output_to_decoupled_machine_after: vec![4], - output_to_original_machine_after: vec![], - place_on_decoupled_machine: vec![], - orig_location: cluster.id().clone(), - decoupled_location: decoupled_cluster.id().clone(), - }; - - let multi_run_metadata = RefCell::new(vec![]); - let built = builder - .optimize_with(|roots| decoupler::decouple(roots, &decoupler, &multi_run_metadata, 0)) - .optimize_with(debug::print_id); - - let (rewritten_ir_builder, ir, _, _, _) = deploy_and_analyze( - &mut reusable_hosts, - &mut deployment, - built, - &clusters, - &processes, - vec![], - None, - &multi_run_metadata, - 0, - ) - .await; - - let built = rewritten_ir_builder.build_with(|_| ir).finalize(); - - // Generate graphs if requested - let _ = built.generate_graph_with_config(&args.graph, None); -} diff --git a/hydro_optimize_examples/examples/network_calibrator.rs b/hydro_optimize_examples/examples/network_calibrator.rs index 2961d48..ffa9952 100644 --- a/hydro_optimize_examples/examples/network_calibrator.rs +++ b/hydro_optimize_examples/examples/network_calibrator.rs @@ -5,11 +5,11 @@ use std::sync::Arc; use clap::Parser; use hydro_deploy::Deployment; use hydro_deploy::gcp::GcpNetwork; -use hydro_lang::viz::config::GraphConfig; use hydro_lang::location::Location; use hydro_lang::prelude::FlowBuilder; +use hydro_lang::viz::config::GraphConfig; use hydro_optimize::deploy::ReusableHosts; -use hydro_optimize::deploy_and_analyze::deploy_and_analyze; +use hydro_optimize::deploy_and_analyze::deploy_and_optimize; use hydro_optimize_examples::network_calibrator::{Aggregator, Client, Server, network_calibrator}; use tokio::sync::RwLock; @@ -60,22 +60,25 @@ async fn main() { let clusters = vec![ ( - server.id().raw_id(), + server.id().key(), std::any::type_name::().to_string(), 1, ), ( - clients.id().raw_id(), + clients.id().key(), std::any::type_name::().to_string(), num_clients, ), ]; let processes = vec![( - client_aggregator.id().raw_id(), + client_aggregator.id().key(), std::any::type_name::().to_string(), )]; - println!("Running network calibrator with message size: {} bytes, num clients: {}", message_size, num_clients); + println!( + "Running network calibrator with message size: {} bytes, num clients: {}", + message_size, num_clients + ); network_calibrator( num_clients_per_node, message_size, @@ -84,26 +87,25 @@ async fn main() { &client_aggregator, ); - let (rewritten_ir_builder, ir, _, _, _) = - deploy_and_analyze( - &mut reusable_hosts, - &mut deployment, - builder.finalize(), - &clusters, - &processes, - vec![ - std::any::type_name::().to_string(), - std::any::type_name::().to_string(), - ], - num_seconds_to_profile, - &multi_run_metadata, - 0, // Set to 0 to turn off comparisons between iterations - ) - .await; + let (rewritten_ir_builder, ir, _, _, _) = deploy_and_optimize( + &mut reusable_hosts, + &mut deployment, + builder.finalize(), + &clusters, + &processes, + vec![ + std::any::type_name::().to_string(), + std::any::type_name::().to_string(), + ], + num_seconds_to_profile, + &multi_run_metadata, + 0, // Set to 0 to turn off comparisons between iterations + ) + .await; let built = rewritten_ir_builder.build_with(|_| ir).finalize(); // Generate graphs if requested _ = built.generate_graph_with_config(&args.graph, None); } -} \ No newline at end of file +} diff --git a/hydro_optimize_examples/examples/partition_simple_cluster.rs b/hydro_optimize_examples/examples/partition_simple_cluster.rs deleted file mode 100644 index 20e9079..0000000 --- a/hydro_optimize_examples/examples/partition_simple_cluster.rs +++ /dev/null @@ -1,80 +0,0 @@ -use std::cell::RefCell; - -use clap::{ArgAction, Parser}; -use hydro_deploy::Deployment; -use hydro_lang::location::Location; -use hydro_lang::viz::config::GraphConfig; -use hydro_optimize::deploy::{HostType, ReusableHosts}; -use hydro_optimize::deploy_and_analyze::deploy_and_analyze; - -#[derive(Parser, Debug)] -#[command(author, version, about, long_about = None, group( - clap::ArgGroup::new("cloud") - .args(&["gcp", "aws"]) - .multiple(false) -))] -struct Args { - #[command(flatten)] - graph: GraphConfig, - - /// Use Gcp for deployment (provide project name) - #[arg(long)] - gcp: Option, - - /// Use Aws, make sure credentials are set up - #[arg(long, action = ArgAction::SetTrue)] - aws: bool, -} - -struct Process {} -struct Cluster {} - -#[tokio::main] -async fn main() { - let args = Args::parse(); - let mut deployment = Deployment::new(); - - let host_type: HostType = if let Some(project) = args.gcp { - HostType::Gcp { project } - } else if args.aws { - HostType::Aws - } else { - HostType::Localhost - }; - - let mut reusable_hosts = ReusableHosts::new(host_type); - - let builder = hydro_lang::compile::builder::FlowBuilder::new(); - let num_cluster_nodes = 2; - let (process, cluster) = hydro_test::cluster::simple_cluster::simple_cluster(&builder); - - let clusters = vec![( - cluster.id().raw_id(), - std::any::type_name::().to_string(), - num_cluster_nodes, - )]; - let processes = vec![( - process.id().raw_id(), - std::any::type_name::().to_string(), - )]; - - let multi_run_metadata = RefCell::new(vec![]); - - let (rewritten_ir_builder, ir, _, _, _) = deploy_and_analyze( - &mut reusable_hosts, - &mut deployment, - builder.finalize(), - &clusters, - &processes, - vec![std::any::type_name::().to_string()], - None, - &multi_run_metadata, - 0, - ) - .await; - - let built = rewritten_ir_builder.build_with(|_| ir).finalize(); - - // Generate graphs if requested - _ = built.generate_graph_with_config(&args.graph, None); -} diff --git a/hydro_optimize_examples/examples/partition_two_pc.rs b/hydro_optimize_examples/examples/partition_two_pc.rs index d793bae..e978bef 100644 --- a/hydro_optimize_examples/examples/partition_two_pc.rs +++ b/hydro_optimize_examples/examples/partition_two_pc.rs @@ -5,7 +5,7 @@ use hydro_deploy::Deployment; use hydro_lang::location::Location; use hydro_lang::viz::config::GraphConfig; use hydro_optimize::deploy::{HostType, ReusableHosts}; -use hydro_optimize::deploy_and_analyze::deploy_and_analyze; +use hydro_optimize::deploy_and_analyze::deploy_and_optimize; use hydro_test::cluster::two_pc::{Coordinator, Participant}; use hydro_test::cluster::two_pc_bench::{Aggregator, Client}; @@ -64,30 +64,30 @@ async fn main() { let clusters = vec![ ( - participants.id().raw_id(), + participants.id().key(), std::any::type_name::().to_string(), num_participants, ), ( - clients.id().raw_id(), + clients.id().key(), std::any::type_name::().to_string(), num_clients, ), ]; let processes = vec![ ( - coordinator.id().raw_id(), + coordinator.id().key(), std::any::type_name::().to_string(), ), ( - client_aggregator.id().raw_id(), + client_aggregator.id().key(), std::any::type_name::().to_string(), ), ]; let multi_run_metadata = RefCell::new(vec![]); - let (rewritten_ir_builder, ir, _, _, _) = deploy_and_analyze( + let (rewritten_ir_builder, ir, _, _, _) = deploy_and_optimize( &mut reusable_hosts, &mut deployment, builder.finalize(), diff --git a/hydro_optimize_examples/examples/perf_paxos.rs b/hydro_optimize_examples/examples/perf_paxos.rs index 545e17f..14930ab 100644 --- a/hydro_optimize_examples/examples/perf_paxos.rs +++ b/hydro_optimize_examples/examples/perf_paxos.rs @@ -6,7 +6,7 @@ use hydro_lang::location::Location; use hydro_lang::viz::config::GraphConfig; use hydro_optimize::decoupler; use hydro_optimize::deploy::{HostType, ReusableHosts}; -use hydro_optimize::deploy_and_analyze::deploy_and_analyze; +use hydro_optimize::deploy_and_analyze::{Optimizations, deploy_and_optimize}; use hydro_test::cluster::kv_replica::Replica; use hydro_test::cluster::paxos::{Acceptor, CorePaxos, PaxosConfig, Proposer}; use hydro_test::cluster::paxos_bench::{Aggregator, Client}; @@ -80,28 +80,28 @@ async fn main() { let mut clusters = vec![ ( - proposers.id().raw_id(), + proposers.id().key(), std::any::type_name::().to_string(), f + 1, ), ( - acceptors.id().raw_id(), + acceptors.id().key(), std::any::type_name::().to_string(), 2 * f + 1, ), ( - clients.id().raw_id(), + clients.id().key(), std::any::type_name::().to_string(), num_clients, ), ( - replicas.id().raw_id(), + replicas.id().key(), std::any::type_name::().to_string(), f + 1, ), ]; let processes = vec![( - client_aggregator.id().raw_id(), + client_aggregator.id().key(), std::any::type_name::().to_string(), )]; @@ -112,40 +112,24 @@ async fn main() { let num_times_to_optimize = 2; for i in 0..num_times_to_optimize { - let (rewritten_ir_builder, mut ir, mut decoupler, bottleneck_name, bottleneck_num_nodes) = - deploy_and_analyze( - &mut reusable_hosts, - &mut deployment, - builder.finalize(), - &clusters, - &processes, - vec![ - std::any::type_name::().to_string(), - std::any::type_name::().to_string(), - ], - None, - &multi_run_metadata, - i, - ) - .await; - - // Apply decoupling - let mut decoupled_cluster = None; - builder = rewritten_ir_builder.build_with(|builder| { - let new_cluster = builder.cluster::<()>(); - decoupler.decoupled_location = new_cluster.id().clone(); - decoupler::decouple(&mut ir, &decoupler, &multi_run_metadata, i); - decoupled_cluster = Some(new_cluster); - - ir - }); - if let Some(new_cluster) = decoupled_cluster { - clusters.push(( - new_cluster.id().raw_id(), - format!("{}-decouple-{}", bottleneck_name, i), - bottleneck_num_nodes, - )); - } + let new_builder = deploy_and_optimize( + &mut reusable_hosts, + &mut deployment, + builder.finalize(), + &mut clusters, + &processes, + vec![ + std::any::type_name::().to_string(), + std::any::type_name::().to_string(), + ], + Optimizations::new().with_decoupling(), + None, + &multi_run_metadata, + i, + ) + .await; + + builder = new_builder; } let built = builder.finalize(); diff --git a/hydro_optimize_examples/src/lobsters.rs b/hydro_optimize_examples/src/lobsters.rs index bd48d87..29df1f1 100644 --- a/hydro_optimize_examples/src/lobsters.rs +++ b/hydro_optimize_examples/src/lobsters.rs @@ -1,10 +1,8 @@ -use std::collections::HashSet; - use hydro_lang::{ - live_collections::stream::NoOrder, + live_collections::{sliced::sliced, stream::NoOrder}, location::{Location, MemberId}, nondet::nondet, - prelude::{Process, Stream, Unbounded}, + prelude::{KeyedStream, Process, Unbounded}, }; use serde::{Deserialize, Serialize}; use sha2::{Digest, Sha256}; @@ -46,63 +44,65 @@ impl PartialOrd for Story { )] pub fn lobsters<'a, Client>( server: &Process<'a, Server>, - add_user: KeyedStream<(MemberId, u32), String, Process<'a, Server>, Unbounded, NoOrder>, - get_users: Stream<(MemberId, u32), Process<'a, Server>, Unbounded, NoOrder>, + add_user: KeyedStream, (u32, String), Process<'a, Server>, Unbounded, NoOrder>, + get_users: KeyedStream, u32, Process<'a, Server>, Unbounded, NoOrder>, add_story: KeyedStream< - (MemberId, u32), - (String, String, Instant), + MemberId, + (u32, String, String, Instant), Process<'a, Server>, Unbounded, NoOrder, >, _add_comment: KeyedStream< - (MemberId, u32), - (String, u32, String, Instant), + MemberId, + (u32, String, u32, String, Instant), Process<'a, Server>, Unbounded, NoOrder, >, _upvote_story: KeyedStream< - (MemberId, u32), - (String, u32), + MemberId, + (u32, String, u32), Process<'a, Server>, Unbounded, NoOrder, >, _upvote_comment: KeyedStream< - (MemberId, u32), - (String, u32), + MemberId, + (u32, String, u32), Process<'a, Server>, Unbounded, NoOrder, >, - _get_stories: Stream<(MemberId, u32), Process<'a, Server>, Unbounded, NoOrder>, - _get_comments: Stream<(MemberId, u32), Process<'a, Server>, Unbounded, NoOrder>, + _get_stories: KeyedStream, u32, Process<'a, Server>, Unbounded, NoOrder>, + _get_comments: KeyedStream, u32, Process<'a, Server>, Unbounded, NoOrder>, _get_story_comments: KeyedStream< - (MemberId, u32), - u32, + MemberId, + (u32, u32), Process<'a, Server>, Unbounded, NoOrder, >, ) -> ( - KeyedStream<(MemberId, u32), Option, Process<'a, Server>, Unbounded, NoOrder>, // add_user response + KeyedStream, (u32, Option), Process<'a, Server>, Unbounded, NoOrder>, // add_user response ) { let user_auth_tick = server.tick(); let stories_tick = server.tick(); + let atomic_add_user = add_user.atomic(&user_auth_tick); // Persisted users - let curr_users = add_user - .map(q!(|(_client_id, username)| ( - username, - self::generate_api_key(username.clone()) + let curr_users = atomic_add_user + .entries() + .map(q!(|(_client_id, (virtual_client_id, username))| ( + username.clone(), + (self::generate_api_key(username), virtual_client_id) ))) .into_keyed() .assume_ordering(nondet!(/** First user wins */)) .first(); // Send response back to client. Only done after the tick to ensure that once the client gets the response, the user has been added let add_user_response = sliced! { - let new_users = use(add_user_with_api_key, nondet!(/** New users requests this tick */)); + let new_users = use(atomic_add_user, nondet!(/** New users requests this tick */)); let curr_users = use(curr_users, nondet!(/** Current users this tick */)); new_users .map(q!(|(client_id, (username, api_key))| { @@ -122,9 +122,10 @@ pub fn lobsters<'a, Client>( .all_ticks(); // Add story - let add_story_pre_join = add_story.map(q!(|(client_id, (api_key, title, timestamp))| { - (api_key, (client_id, title, timestamp)) - })); + let add_story_pre_join = + add_story.map(q!(|(client_id, (req_id, api_key, title, timestamp))| { + (api_key, (client_id, req_id, title, timestamp)) + })); let stories = add_story_pre_join .batch( &user_auth_tick, @@ -150,7 +151,7 @@ pub fn lobsters<'a, Client>( let _top_stories = curr_stories.clone().persist().fold_commutative_idempotent( q!(|| vec![]), q!( - |vec, (_api_key, ((_client_id, title, timestamp), username))| { + |vec, (_api_key, ((_client_id, _req_id, title, timestamp), username))| { let new_elem = (title, timestamp, username); // TODO: Use a binary heap // TODO: Create a struct that is ordered by timestamp diff --git a/hydro_optimize_examples/src/lock_server.rs b/hydro_optimize_examples/src/lock_server.rs index 359f99f..9c3e767 100644 --- a/hydro_optimize_examples/src/lock_server.rs +++ b/hydro_optimize_examples/src/lock_server.rs @@ -1,8 +1,8 @@ use hydro_lang::{ - live_collections::stream::NoOrder, + live_collections::{sliced::sliced, stream::NoOrder}, location::{Location, MemberId}, nondet::nondet, - prelude::{KeyedStream, Process, Unbounded}, + prelude::{KeyedStream, Process, Stream, Unbounded}, }; use stageleft::q; @@ -26,60 +26,54 @@ pub fn lock_server<'a, Client>( KeyedStream, (u32, u32), Process<'a, Server>, Unbounded, NoOrder>, ) { let server_tick = server.tick(); - let keyed_payloads = payloads + let mapped_acquires = acquires + .clone() .entries() - .map(q!(|(client_id, (virt_client_id, lock_id, acquire))| ( + .map(q!(|(client_id, (virtual_client_id, lock_id))| ( lock_id, - (client_id, virt_client_id, acquire) + (client_id, virtual_client_id) ))) .into_keyed(); - - let batched_payloads = keyed_payloads - .assume_ordering(nondet!(/** For each key, the first to acquire the lock wins */)); - let lock_state = batched_payloads.clone().across_ticks(|stream| { - stream.reduce(q!( - |(curr_client_id, curr_virt_client_id, is_held_by_client), - (client_id, virt_client_id, acquire)| { - if acquire { - // If the lock is currently held by the server, give the client the lock - if !*is_held_by_client { - *curr_client_id = client_id; - *curr_virt_client_id = virt_client_id; - *is_held_by_client = true; - } - } else { - // If the client is releasing the lock and it holds it, give the lock back to the server - if *is_held_by_client - && *curr_virt_client_id == virt_client_id - && *curr_client_id == client_id - { - *is_held_by_client = false; - } - } - } - )) - }); - let results = batched_payloads - .cross_singleton(lock_state) - .all_ticks() - .map(q!(|( + let mapped_releases = releases + .clone() + .entries() + .map(q!(|(client_id, (virtual_client_id, lock_id))| ( lock_id, - ( - (client_id, virt_client_id, acquire), - (curr_client_id, curr_virt_client_id, is_held_by_client), - ), - )| { - if acquire { - let acquired = is_held_by_client - && curr_client_id == client_id - && curr_virt_client_id == virt_client_id; - (client_id, (virt_client_id, lock_id, acquired)) - } else { - // Releasing always succeeds - (client_id, (virt_client_id, lock_id, true)) - } - })); - results + (client_id, virtual_client_id) + ))) + .into_keyed(); + + sliced! { + let mapped_acquires = use(mapped_acquires, nondet!(/** For each lock, pick a random acquire as the winner */)); + let mapped_releases = use(mapped_releases, nondet!(/** For each lock, only one release should succeed (the owner of the lock) */)); + + // lock_id + let mut free_locks = use::state_null::>(); + // (lock_id, (client_id, virtual_client_id)) + let mut acquired_locks = use::state_null::, u32)), _, _, _>>(); + let keyed_acquired_locks = acquired_locks.into_keyed().first(); + // For each lock, pick a random acquire as the winner + + // Always process releases first + let new_free_locks = keyed_acquired_locks + .clone() + .get_many_if_present(mapped_releases) + .filter(q!(|((holder_client_id, holder_virtual_client_id), (client_id, virtual_client_id))| + holder_client_id == client_id && holder_virtual_client_id == virtual_client_id + )) + .keys() + .chain(free_locks); + + let winning_acquires = mapped_acquires.assume_ordering(nondet!(/** Randomly pick one acquire to be the winner */)).first(); + + // Process acquires for locks that exist + // TODO: Requires join_stream + + // Create new locks if it's not currently free or acquired + let created_locks = winning_acquires + .filter_key_not_in(new_free_locks) + .filter_key_not_in(keyed_acquired_locks.keys()); + }; } /// Lock server implementation as described in https://dl.acm.org/doi/pdf/10.1145/3341301.3359651, with the difference being that each server can hold multiple locks. @@ -120,6 +114,7 @@ pub fn assume_order_lock_server<'a, Client>( let payloads = atomic_acquires.interleave(atomic_releases).into_keyed(); let lock_state = payloads + .clone() .assume_ordering(nondet!(/** Process in arrival order */)) .fold( q!(|| None), @@ -145,13 +140,21 @@ pub fn assume_order_lock_server<'a, Client>( // TODO let acquire_results = sliced! { - let payloads = use::atomic(payloads, nondet!(/** Payloads at this tick */)); + let payloads = use::atomic(payloads.clone(), nondet!(/** Payloads at this tick */)); let locks_snapshot = use::atomic(lock_state, nondet!(/** Snapshot of lock state at this tick */)); - payloads.clone() - .filter(q!(|(_, (_, _, acquire))| acquire)) - .cross_singleton(locks_snapshot) - }; + let acquires = payloads.filter(q!(|(_, _, acquire)| *acquire)); + locks_snapshot.get_many_if_present(acquires) + } + .map(q!(|(curr_holder, (client_id, virtual_client_id, _acquire))| { + let lock_acquired = curr_holder.is_some_and(|(holder_client_id, holder_virtual_client_id)| { + holder_client_id == client_id && holder_virtual_client_id == virtual_client_id + }); + (client_id, virtual_client_id, lock_acquired) + })) + .entries() + .map(q!(|(lock_id, (client_id, virtual_client_id, acquired))| (client_id, (virtual_client_id, lock_id, acquired)))) + .into_keyed(); let release_results = payloads .end_atomic() diff --git a/hydro_optimize_examples/src/network_calibrator.rs b/hydro_optimize_examples/src/network_calibrator.rs index 381a731..eaee198 100644 --- a/hydro_optimize_examples/src/network_calibrator.rs +++ b/hydro_optimize_examples/src/network_calibrator.rs @@ -1,7 +1,7 @@ use hydro_lang::{ live_collections::stream::NoOrder, nondet::nondet, - prelude::{Cluster, KeyedStream, Process, Stream, TCP, Unbounded}, + prelude::{Cluster, KeyedStream, Process, TCP, Unbounded}, }; use hydro_std::bench_client::{bench_client, compute_throughput_latency, print_bench_results}; @@ -21,15 +21,17 @@ pub fn network_calibrator<'a>( let latencies = bench_client( clients, num_clients_per_node, - |_client, ids_and_prev_payloads| { + |ids_and_prev_payloads| { size_based_workload_generator(message_size, ids_and_prev_payloads) }, |payloads| { // Server just echoes the payload payloads + .entries() .broadcast(server, TCP.bincode(), nondet!(/** Test */)) .demux(clients, TCP.bincode()) .values() + .into_keyed() }, ).values().map(q!(|(_client_id, latency)| latency)); From 8f0142df3d2ee0eb5deba75d53cf58f055850d3d Mon Sep 17 00:00:00 2001 From: David Chu Date: Wed, 28 Jan 2026 13:28:04 -0800 Subject: [PATCH 18/35] Cleaner deploy_and_analyze API, remove MultiRunMetadata --- Cargo.lock | 22 +- hydro_optimize/src/decoupler.rs | 15 +- hydro_optimize/src/deploy_and_analyze.rs | 300 ++++++++------- hydro_optimize/src/parse_results.rs | 362 +----------------- hydro_optimize/src/rewrites.rs | 11 +- .../examples/benchmark_paxos.rs | 50 +-- .../examples/network_calibrator.rs | 54 +-- .../examples/partition_two_pc.rs | 54 +-- .../examples/perf_paxos.rs | 82 ++-- 9 files changed, 246 insertions(+), 704 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 2b7f551..a673fca 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -895,7 +895,7 @@ dependencies = [ [[package]] name = "copy_span" version = "0.1.0" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" dependencies = [ "proc-macro2", "syn", @@ -1114,7 +1114,7 @@ dependencies = [ [[package]] name = "dfir_lang" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" dependencies = [ "auto_impl", "documented", @@ -1780,7 +1780,7 @@ checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" [[package]] name = "hydro_build_utils" version = "0.0.1" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" dependencies = [ "insta", "rustc_version", @@ -1789,7 +1789,7 @@ dependencies = [ [[package]] name = "hydro_deploy" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" dependencies = [ "anyhow", "append-only-vec", @@ -1825,7 +1825,7 @@ dependencies = [ [[package]] name = "hydro_deploy_integration" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" dependencies = [ "async-recursion", "async-trait", @@ -1843,7 +1843,7 @@ dependencies = [ [[package]] name = "hydro_lang" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" dependencies = [ "auto_impl", "backtrace", @@ -1934,7 +1934,7 @@ dependencies = [ [[package]] name = "hydro_std" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" dependencies = [ "hdrhistogram", "hydro_lang", @@ -1946,7 +1946,7 @@ dependencies = [ [[package]] name = "hydro_test" version = "0.0.0" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" dependencies = [ "bytes", "colored", @@ -2156,7 +2156,7 @@ dependencies = [ [[package]] name = "include_mdtests" version = "0.0.0" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" dependencies = [ "glob", "proc-macro2", @@ -4005,7 +4005,7 @@ checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa" [[package]] name = "sinktools" version = "0.0.1" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" dependencies = [ "futures-util", "pin-project-lite", @@ -4789,7 +4789,7 @@ checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" [[package]] name = "variadics" version = "0.0.10" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#b0db21bc7e60de66e144f807474a645eb87e2ea8" +source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" dependencies = [ "hashbrown 0.14.5", "hydro_build_utils", diff --git a/hydro_optimize/src/decoupler.rs b/hydro_optimize/src/decoupler.rs index ada5f28..c24c3ec 100644 --- a/hydro_optimize/src/decoupler.rs +++ b/hydro_optimize/src/decoupler.rs @@ -13,8 +13,7 @@ use serde::{Deserialize, Serialize}; use stageleft::quote_type; use syn::visit_mut::VisitMut; -use crate::parse_results::{MultiRunMetadata, get_or_append_run_metadata}; -use crate::repair::{cycle_source_to_sink_input, inject_id, inject_location}; +use crate::repair::{cycle_source_to_sink_input, inject_location}; use crate::rewrites::{ ClusterSelfIdReplace, collection_kind_to_debug_type, deserialize_bincode_with_type, prepend_member_id_to_collection_kind, serialize_bincode_with_type, tee_to_inner_id, @@ -262,8 +261,6 @@ fn fix_cluster_self_id_node(node: &mut HydroNode, mut locations: ClusterSelfIdRe pub fn decouple( ir: &mut [HydroRoot], decoupler: &Decoupler, - multi_run_metadata: &RefCell, - iteration: usize, ) { let tee_to_inner_id_before_rewrites = tee_to_inner_id(ir); let mut new_inners = HashMap::new(); @@ -281,11 +278,6 @@ pub fn decouple( }, ); - // Fix IDs since we injected nodes - let new_id_to_old_id = inject_id(ir); - let mut mut_multi_run_metadata = multi_run_metadata.borrow_mut(); - let run_metadata = get_or_append_run_metadata(&mut mut_multi_run_metadata, iteration + 1); - run_metadata.op_id_to_prev_iteration_op_id = new_id_to_old_id; // Fix locations since we changed some let cycle_source_to_sink_input = cycle_source_to_sink_input(ir); inject_location(ir, &cycle_source_to_sink_input); @@ -308,7 +300,6 @@ pub fn decouple( #[cfg(test)] mod tests { - use std::cell::RefCell; use std::collections::HashSet; use hydro_build_utils::insta; @@ -350,8 +341,6 @@ mod tests { .assume_retries(nondet!(/** test */)) .for_each(q!(|a| println!("Got it: {}", a))); - let multi_run_metadata = RefCell::new(vec![]); - let iteration = 0; let built = builder.optimize_with(|ir| { inject_id(ir); print_id(ir); @@ -381,7 +370,7 @@ mod tests { decoupled_location: decoupled_cluster.id().clone(), orig_location: send_cluster.id().clone(), }; - decouple(ir, &decoupler, &multi_run_metadata, iteration) + decouple(ir, &decoupler); }); (send_cluster, recv_cluster, decoupled_cluster, built) } diff --git a/hydro_optimize/src/deploy_and_analyze.rs b/hydro_optimize/src/deploy_and_analyze.rs index 5c39b2f..5a70e1a 100644 --- a/hydro_optimize/src/deploy_and_analyze.rs +++ b/hydro_optimize/src/deploy_and_analyze.rs @@ -1,4 +1,3 @@ -use std::cell::RefCell; use std::collections::HashMap; use std::time::Duration; @@ -8,19 +7,17 @@ use hydro_lang::compile::deploy::DeployResult; use hydro_lang::compile::ir::{HydroNode, HydroRoot, deep_clone, traverse_dfir}; use hydro_lang::deploy::HydroDeploy; use hydro_lang::deploy::deploy_graph::DeployCrateWrapper; +use hydro_lang::location::Location; use hydro_lang::location::LocationKey; use hydro_lang::location::dynamic::LocationId; -use hydro_lang::prelude::FlowBuilder; +use hydro_lang::prelude::{Cluster, FlowBuilder, Process}; use hydro_lang::telemetry::Sidecar; use tokio::sync::mpsc::UnboundedReceiver; use crate::decouple_analysis::decouple_analysis; use crate::decoupler::{self, Decoupler}; use crate::deploy::ReusableHosts; -use crate::parse_results::{ - MultiRunMetadata, analyze_cluster_results, analyze_send_recv_overheads, - compare_expected_performance, get_or_append_run_metadata, -}; +use crate::parse_results::{RunMetadata, analyze_cluster_results, analyze_send_recv_overheads}; use crate::repair::{cycle_source_to_sink_input, inject_id, remove_counter}; const COUNTER_PREFIX: &str = "_optimize_counter"; @@ -90,7 +87,7 @@ fn insert_counter_node(node: &mut HydroNode, next_stmt_id: &mut usize, duration: } } -fn insert_counter(ir: &mut [HydroRoot], duration: syn::Expr) { +fn insert_counter(ir: &mut [HydroRoot], duration: &syn::Expr) { traverse_dfir::( ir, |_, _| {}, @@ -168,10 +165,50 @@ impl Sidecar for ScriptSidecar { } } +pub struct ReusableClusters { + named_clusters: Vec<(LocationKey, String, usize)>, +} + +impl ReusableClusters { + pub fn new() -> Self { + Self { + named_clusters: vec![], + } + } + + pub fn with_cluster(mut self, cluster: Cluster<'_, C>, num_members: usize) -> Self { + self.named_clusters.push(( + cluster.id().key(), + std::any::type_name::().to_string(), + num_members, + )); + self + } +} + +pub struct ReusableProcesses { + named_processes: Vec<(LocationKey, String)>, +} + +impl ReusableProcesses { + pub fn new() -> Self { + Self { + named_processes: vec![], + } + } + + pub fn with_process

(mut self, process: Process<'_, P>) -> Self { + self.named_processes + .push((process.id().key(), std::any::type_name::

().to_string())); + self + } +} + pub struct Optimizations { decoupling: bool, partitioning: bool, - iterations: usize, // Performs no optimizations if iterations = 0 + exclude: Vec, + iterations: usize, // Must be at least 1 } impl Optimizations { @@ -179,27 +216,28 @@ impl Optimizations { Self { decoupling: false, partitioning: false, - iterations: 0, + exclude: vec![], + iterations: 1, } } pub fn with_decoupling(mut self) -> Self { self.decoupling = true; - if self.iterations == 0 { - self.iterations = 1; - } self } pub fn with_partitioning(mut self) -> Self { self.partitioning = true; - if self.iterations == 0 { - self.iterations = 1; - } self } - + + pub fn excluding(mut self) -> Self { + self.exclude.push(std::any::type_name::().to_string()); + self + } + pub fn with_iterations(mut self, iterations: usize) -> Self { + assert!(iterations > 0); self.iterations = iterations; self } @@ -213,137 +251,127 @@ impl Optimizations { pub async fn deploy_and_optimize<'a>( reusable_hosts: &mut ReusableHosts, deployment: &mut Deployment, - builder: BuiltFlow<'a>, - clusters: &mut Vec<(LocationKey, String, usize)>, - processes: &Vec<(LocationKey, String)>, - exclude_from_rewrites: Vec, + mut builder: BuiltFlow<'a>, + mut clusters: ReusableClusters, + processes: ReusableProcesses, optimizations: Optimizations, num_seconds: Option, - multi_run_metadata: &RefCell, - iteration: usize, // Starts at 0, how many times this function has been called -) -> FlowBuilder<'a> { +) { let counter_output_duration = syn::parse_quote!(std::time::Duration::from_secs(1)); - // Rewrite with counter tracking - let mut post_rewrite_builder = FlowBuilder::from_built(&builder); - let optimized = builder.optimize_with(|leaf| { - inject_id(leaf); - insert_counter(leaf, counter_output_duration); - }); - let mut ir = deep_clone(optimized.ir()); - - // Insert all clusters & processes - let mut deployable = optimized.into_deploy(); - for (cluster_id, name, num_hosts) in clusters { - deployable = deployable.with_cluster_erased( - *cluster_id, - reusable_hosts.get_cluster_hosts(deployment, name.clone(), *num_hosts), - ); - } - for (process_id, name) in processes { - deployable = deployable.with_process_erased( - *process_id, - reusable_hosts.get_process_hosts(deployment, name.clone()), - ); + if optimizations.iterations > 1 && num_seconds.is_none() { + panic!("Cannot specify multiple iterations without bounding run time"); } - let network_sidecar = ScriptSidecar { - script: "sar -n DEV 1".to_string(), - }; - let nodes = deployable - .with_sidecar_all(&network_sidecar) // Measure network usage - .deploy(deployment); - deployment.deploy().await.unwrap(); - - let (mut usage_out, mut cardinality_out) = track_cluster_usage_cardinality(&nodes).await; - - // Wait for user to input a newline - deployment - .start_until(async { - if let Some(seconds) = num_seconds { - // Wait for some number of seconds - tokio::time::sleep(Duration::from_secs(seconds as u64)).await; - } else { - // Wait for a new line - eprintln!("Press enter to stop deployment and analyze results"); - let _ = tokio::io::AsyncBufReadExt::lines(tokio::io::BufReader::new( - tokio::io::stdin(), - )) - .next_line() - .await - .unwrap(); - } - }) - .await - .unwrap(); - - // Add metadata for this run - let mut mut_multi_run_metadata = multi_run_metadata.borrow_mut(); - let run_metadata = get_or_append_run_metadata(&mut mut_multi_run_metadata, iteration); - let (bottleneck, bottleneck_name, bottleneck_num_nodes) = analyze_cluster_results( - &nodes, - &mut ir, - &mut usage_out, - &mut cardinality_out, - run_metadata, - exclude_from_rewrites, - ) - .await; - // Remove HydroNode::Counter (since we don't want to consider decoupling those) - remove_counter(&mut ir); - - // Create a mapping from each CycleSink to its corresponding CycleSource - let cycle_source_to_sink_input = cycle_source_to_sink_input(&mut ir); - analyze_send_recv_overheads(&mut ir, run_metadata); - let send_overhead = run_metadata - .send_overhead - .get(&bottleneck) - .cloned() - .unwrap_or_default(); - let recv_overhead = run_metadata - .recv_overhead - .get(&bottleneck) - .cloned() - .unwrap_or_default(); - - // Check the expected/actual CPU usages before/after rewrites - std::mem::drop(mut_multi_run_metadata); // Release borrow - compare_expected_performance(&mut ir, multi_run_metadata, iteration); - - if optimizations.decoupling { - let decision = decouple_analysis( - &mut ir, - &bottleneck, - send_overhead, - recv_overhead, - &cycle_source_to_sink_input, - ); - - // Apply decoupling - let mut decoupled_cluster = None; - let new_cluster = post_rewrite_builder.cluster::<()>(); - let decouple_with_location = Decoupler { - decision, - orig_location: bottleneck, - decoupled_location: new_cluster.id().clone(), + + for iteration in 0..optimizations.iterations { + // Rewrite with counter tracking + let mut post_rewrite_builder = FlowBuilder::from_built(&builder); + let optimized = builder.optimize_with(|leaf| { + inject_id(leaf); + insert_counter(leaf, &counter_output_duration); + }); + let mut ir = deep_clone(optimized.ir()); + + // Insert all clusters & processes + let mut deployable = optimized.into_deploy(); + for (cluster_id, name, num_hosts) in clusters.named_clusters.iter() { + deployable = deployable.with_cluster_erased( + *cluster_id, + reusable_hosts.get_cluster_hosts(deployment, name.clone(), *num_hosts), + ); + } + for (process_id, name) in processes.named_processes.iter() { + deployable = deployable.with_process_erased( + *process_id, + reusable_hosts.get_process_hosts(deployment, name.clone()), + ); + } + let network_sidecar = ScriptSidecar { + script: "sar -n DEV 1".to_string(), }; - decoupler::decouple( + let nodes = deployable + .with_sidecar_all(&network_sidecar) // Measure network usage + .deploy(deployment); + deployment.deploy().await.unwrap(); + + let (mut usage_out, mut cardinality_out) = track_cluster_usage_cardinality(&nodes).await; + + // Wait for user to input a newline + deployment + .start_until(async { + if let Some(seconds) = num_seconds { + // Wait for some number of seconds + tokio::time::sleep(Duration::from_secs(seconds as u64)).await; + } else { + // Wait for a new line + eprintln!("Press enter to stop deployment and analyze results"); + let _ = tokio::io::AsyncBufReadExt::lines(tokio::io::BufReader::new( + tokio::io::stdin(), + )) + .next_line() + .await + .unwrap(); + } + }) + .await + .unwrap(); + + // Add metadata for this run + let mut run_metadata = RunMetadata::default(); + let (bottleneck, bottleneck_name, bottleneck_num_nodes) = analyze_cluster_results( + &nodes, &mut ir, - &decouple_with_location, - &multi_run_metadata, - iteration, - ); - post_rewrite_builder.replace_ir(ir); - decoupled_cluster = Some(new_cluster); - - if let Some(new_cluster) = decoupled_cluster { - clusters.push(( + &mut usage_out, + &mut cardinality_out, + &mut run_metadata, + &optimizations.exclude, + ) + .await; + // Remove HydroNode::Counter (since we don't want to consider decoupling those) + remove_counter(&mut ir); + + // Create a mapping from each CycleSink to its corresponding CycleSource + let cycle_source_to_sink_input = cycle_source_to_sink_input(&mut ir); + analyze_send_recv_overheads(&mut ir, &mut run_metadata); + let send_overhead = run_metadata + .send_overhead + .get(&bottleneck) + .cloned() + .unwrap_or_default(); + let recv_overhead = run_metadata + .recv_overhead + .get(&bottleneck) + .cloned() + .unwrap_or_default(); + + // TODO: Output overheads to file + + if optimizations.decoupling { + let decision = decouple_analysis( + &mut ir, + &bottleneck, + send_overhead, + recv_overhead, + &cycle_source_to_sink_input, + ); + + // Apply decoupling + let new_cluster = post_rewrite_builder.cluster::<()>(); + let decouple_with_location = Decoupler { + decision, + orig_location: bottleneck, + decoupled_location: new_cluster.id().clone(), + }; + decoupler::decouple(&mut ir, &decouple_with_location); + post_rewrite_builder.replace_ir(ir); + clusters.named_clusters.push(( new_cluster.id().key(), format!("{}-decouple-{}", bottleneck_name, iteration), bottleneck_num_nodes, )); + // TODO: Save decoupling decision to file } - // TODO: Save decoupling decision to file - } - post_rewrite_builder + builder = post_rewrite_builder.finalize(); + } } diff --git a/hydro_optimize/src/parse_results.rs b/hydro_optimize/src/parse_results.rs index 1969264..cf053f0 100644 --- a/hydro_optimize/src/parse_results.rs +++ b/hydro_optimize/src/parse_results.rs @@ -1,9 +1,8 @@ -use std::cell::RefCell; -use std::collections::{HashMap, HashSet}; +use std::collections::HashMap; use hydro_lang::compile::deploy::DeployResult; use hydro_lang::compile::ir::{ - HydroIrMetadata, HydroIrOpMetadata, HydroNode, HydroRoot, traverse_dfir, + HydroNode, HydroRoot, traverse_dfir, }; use hydro_lang::deploy::HydroDeploy; use hydro_lang::deploy::deploy_graph::DeployCrateWrapper; @@ -11,25 +10,14 @@ use hydro_lang::location::dynamic::LocationId; use regex::Regex; use tokio::sync::mpsc::UnboundedReceiver; -use crate::debug::print_id; - #[derive(Default)] pub struct RunMetadata { pub send_overhead: HashMap, pub recv_overhead: HashMap, pub unaccounted_perf: HashMap, // % of perf samples not mapped to any operator pub total_usage: HashMap, // 100% CPU = 1.0 - pub op_id_to_prev_iteration_op_id: HashMap, - pub op_id_to_location: HashMap, - pub op_id_to_cpu_usage: HashMap, - pub op_id_to_recv_cpu_usage: HashMap, - pub op_id_to_cardinality: HashMap, - pub op_id_to_input_op_id: HashMap>, - pub network_op_id: HashSet, } -pub type MultiRunMetadata = Vec; - pub fn parse_cpu_usage(measurement: String) -> f64 { let regex = Regex::new(r"Total (\d+\.\d+)%").unwrap(); regex @@ -228,7 +216,7 @@ pub async fn analyze_cluster_results( usage_out: &mut HashMap<(LocationId, String, usize), UnboundedReceiver>, cardinality_out: &mut HashMap<(LocationId, String, usize), UnboundedReceiver>, run_metadata: &mut RunMetadata, - exclude: Vec, + exclude: &Vec, ) -> (LocationId, String, usize) { let mut max_usage_cluster_id = None; let mut max_usage_cluster_size = 0; @@ -354,347 +342,3 @@ pub fn analyze_send_recv_overheads(ir: &mut [HydroRoot], run_metadata: &mut RunM println!("Max recv overhead at {:?}: {}", location, overhead); } } - -pub fn get_or_append_run_metadata( - multi_run_metadata: &mut MultiRunMetadata, - iteration: usize, -) -> &mut RunMetadata { - while multi_run_metadata.len() < iteration + 1 { - multi_run_metadata.push(RunMetadata::default()); - } - multi_run_metadata.get_mut(iteration).unwrap() -} - -fn op_id_to_orig_id( - op_id: usize, - multi_run_metadata: &RefCell, - iteration: usize, -) -> Option { - if iteration == 0 { - return Some(op_id); - } - if let Some(prev_iter_id) = multi_run_metadata - .borrow() - .get(iteration) - .unwrap() - .op_id_to_prev_iteration_op_id - .get(&op_id) - { - op_id_to_orig_id(*prev_iter_id, multi_run_metadata, iteration - 1) - } else { - None - } -} - -fn record_metadata( - metadata: &HydroIrOpMetadata, - input_metadata: Vec<&HydroIrMetadata>, - run_metadata: &mut RunMetadata, -) { - let id = metadata.id.unwrap(); - - if let Some(cpu_usage) = metadata.cpu_usage { - run_metadata.op_id_to_cpu_usage.insert(id, cpu_usage); - } - if let Some(network_recv_cpu_usage) = metadata.network_recv_cpu_usage { - run_metadata - .op_id_to_recv_cpu_usage - .insert(id, network_recv_cpu_usage); - } - - let input_ids = input_metadata - .iter() - .filter_map(|input| input.op.id) - .collect(); - run_metadata.op_id_to_input_op_id.insert(id, input_ids); -} - -fn record_metadata_root(root: &mut HydroRoot, run_metadata: &mut RunMetadata) { - record_metadata( - root.op_metadata(), - vec![root.input_metadata()], - run_metadata, - ); - - // Location = input's location, cardinality = input's cardinality - let id = root.op_metadata().id.unwrap(); - let input = root.input_metadata(); - run_metadata - .op_id_to_location - .insert(id, input.location_id.root().clone()); - if let Some(cardinality) = input.cardinality { - run_metadata.op_id_to_cardinality.insert(id, cardinality); - } -} - -fn record_metadata_node(node: &mut HydroNode, run_metadata: &mut RunMetadata) { - record_metadata(node.op_metadata(), node.input_metadata(), run_metadata); - - let id = node.op_metadata().id.unwrap(); - let metadata = node.metadata(); - run_metadata - .op_id_to_location - .insert(id, metadata.location_id.root().clone()); - if let Some(cardinality) = metadata.cardinality { - run_metadata.op_id_to_cardinality.insert(id, cardinality); - } - - // Track network nodes - if let HydroNode::Network { .. } = node { - run_metadata.network_op_id.insert(id); - } -} - -fn compare_expected_values( - new_value: f64, - old_value: f64, - new_location: &LocationId, - old_location: &LocationId, - orig_id: usize, - value_name: &str, -) { - println!( - "New location {:?}, old location {:?}: Operator {} {}, new value {:?}, old value {:?}", - new_location, old_location, orig_id, value_name, new_value, old_value - ); -} - -/// If the op_id is a network node, return the sender's location by checking its parent. Otherwise return the operator's location -fn sender_location_if_network(run_metadata: &RunMetadata, op_id: usize) -> &LocationId { - if run_metadata.network_op_id.contains(&op_id) { - let parent = run_metadata.op_id_to_input_op_id.get(&op_id).unwrap(); - assert!( - parent.len() == 1, - "Network operator should have exactly one input" - ); - run_metadata.op_id_to_location.get(&parent[0]).unwrap() - } else { - run_metadata.op_id_to_location.get(&op_id).unwrap() - } -} - -/// Compares the performance of the current iteration against the previous one. -pub fn compare_expected_performance( - ir: &mut [HydroRoot], - multi_run_metadata: &RefCell, - iteration: usize, -) { - print_id(ir); - - // Record run_metadata - traverse_dfir::( - ir, - |root, _| { - record_metadata_root( - root, - multi_run_metadata.borrow_mut().get_mut(iteration).unwrap(), - ); - }, - |node, _| { - record_metadata_node( - node, - multi_run_metadata.borrow_mut().get_mut(iteration).unwrap(), - ); - }, - ); - - // Nothing to compare against for the 1st run, return - if iteration == 0 { - return; - } - - // Compare against previous runs - let borrowed_multi_run_metadata = multi_run_metadata.borrow(); - let run_metadata = borrowed_multi_run_metadata.get(iteration).unwrap(); - let prev_run_metadata = borrowed_multi_run_metadata.get(iteration - 1).unwrap(); - - // 1. Compare operators with an orig_id - for (op_id, prev_id) in run_metadata.op_id_to_prev_iteration_op_id.iter() { - let orig_id = op_id_to_orig_id(*op_id, multi_run_metadata, iteration).unwrap(); - let new_location = run_metadata.op_id_to_location.get(op_id).unwrap(); - let old_location = prev_run_metadata.op_id_to_location.get(prev_id).unwrap(); - - // Compare CPU usage - if let Some(cpu_usage) = run_metadata.op_id_to_cpu_usage.get(op_id) - && let Some(prev_cpu_usage) = prev_run_metadata.op_id_to_cpu_usage.get(prev_id) - { - compare_expected_values( - *cpu_usage, - *prev_cpu_usage, - sender_location_if_network(run_metadata, *op_id), - sender_location_if_network(prev_run_metadata, *prev_id), - orig_id, - "CPU usage", - ); - } - - // Compare recv CPU usage - if let Some(network_recv_cpu_usage) = run_metadata.op_id_to_recv_cpu_usage.get(op_id) - && let Some(prev_network_recv_cpu_usage) = - prev_run_metadata.op_id_to_recv_cpu_usage.get(prev_id) - { - compare_expected_values( - *network_recv_cpu_usage, - *prev_network_recv_cpu_usage, - new_location, - old_location, - orig_id, - "recv CPU usage", - ); - } - - // Compare cardinality - if let Some(cardinality) = run_metadata.op_id_to_cardinality.get(op_id) - && let Some(prev_cardinality) = prev_run_metadata.op_id_to_cardinality.get(prev_id) - { - compare_expected_values( - *cardinality as f64, - *prev_cardinality as f64, - new_location, - old_location, - orig_id, - "cardinality", - ); - } - } - - // 2. Compare operators without orig_id (added by decoupling) - let mut prev_id_and_loc_to_send_usage = HashMap::new(); // (id in prev iteration, LocationId of sender) -> CPU usage of decoupled output nodes - let mut prev_id_and_loc_to_recv_usage = HashMap::new(); // (id in prev iteration, LocationId of receiver) -> CPU usage of decoupled input nodes - for (id, location) in run_metadata.op_id_to_location.iter() { - if run_metadata.op_id_to_prev_iteration_op_id.contains_key(id) { - continue; - } - - // A. Find the ancestor that existed in the previous iteration - let mut parent_id = None; - let mut parent_prev_id = None; - let mut curr_id = *id; - while parent_prev_id.is_none() { - let inputs = run_metadata.op_id_to_input_op_id.get(&curr_id).unwrap(); - assert_eq!( - inputs.len(), - 1, - "Warning: Location {:?}: Created operator {} has {} inputs, expected 1", - location, - id, - inputs.len() - ); - let input = inputs[0]; - - if let Some(prev_id) = run_metadata.op_id_to_prev_iteration_op_id.get(&input) { - parent_prev_id = Some(*prev_id); - parent_id = Some(input); - } else { - curr_id = input; - } - } - - // B. Add this operator's usages - let parent_location = run_metadata - .op_id_to_location - .get(&parent_id.unwrap()) - .unwrap(); - let is_network = run_metadata.network_op_id.contains(id); - - if parent_location == location || is_network { - // This operator is on the sender - if let Some(cpu_usage) = run_metadata.op_id_to_cpu_usage.get(id) { - prev_id_and_loc_to_send_usage - .entry(( - parent_prev_id.unwrap(), - sender_location_if_network(run_metadata, *id), - )) - .and_modify(|usage| { - *usage += *cpu_usage; - }) - .or_insert_with(|| *cpu_usage); - } - } - if parent_location != location || is_network { - // This operator is on the recipient - let cpu_usage = if is_network { - run_metadata.op_id_to_recv_cpu_usage.get(id) - } else { - run_metadata.op_id_to_cpu_usage.get(id) - }; - - if let Some(cpu_usage) = cpu_usage { - prev_id_and_loc_to_recv_usage - .entry((parent_prev_id.unwrap(), location.clone())) - .and_modify(|usage| { - *usage += *cpu_usage; - }) - .or_insert_with(|| *cpu_usage); - } - } - } - // C. Compare changes in send CPU usage - for ((prev_id, location), cpu_usage) in prev_id_and_loc_to_send_usage { - if let Some(prev_cardinality) = prev_run_metadata.op_id_to_cardinality.get(&prev_id) - && let Some(prev_location) = prev_run_metadata.op_id_to_location.get(&prev_id) - { - compare_expected_values( - cpu_usage, - prev_run_metadata - .send_overhead - .get(prev_location) - .cloned() - .unwrap_or_default() - * *prev_cardinality as f64, - location, - prev_location, - op_id_to_orig_id(prev_id, multi_run_metadata, iteration - 1).unwrap(), - "decoupled send CPU usage", - ); - } - } - // D. Compare changes in recv CPU usage - for ((prev_id, location), cpu_usage) in prev_id_and_loc_to_recv_usage { - if let Some(prev_cardinality) = prev_run_metadata.op_id_to_cardinality.get(&prev_id) - && let Some(prev_location) = prev_run_metadata.op_id_to_location.get(&prev_id) - { - compare_expected_values( - cpu_usage, - prev_run_metadata - .recv_overhead - .get(prev_location) - .cloned() - .unwrap_or_default() - * *prev_cardinality as f64, - &location, - prev_location, - op_id_to_orig_id(prev_id, multi_run_metadata, iteration - 1).unwrap(), - "decoupled recv CPU usage", - ); - } - } - - // 3. Compare changes in unexplained CPU usage - for (location, unexplained) in &run_metadata.unaccounted_perf { - if let Some(old_unexplained) = prev_run_metadata.unaccounted_perf.get(location) { - println!( - "Location {:?}'s unexplained CPU usage changed from {} to {}", - location, old_unexplained, unexplained - ); - } - } - - // 4. Compare changes in send/recv overheads - for (location, send_overhead) in &run_metadata.send_overhead { - if let Some(old_send_overhead) = prev_run_metadata.send_overhead.get(location) { - println!( - "Location {:?}'s send overhead changed from {} to {}", - location, old_send_overhead, send_overhead - ); - } - } - for (location, recv_overhead) in &run_metadata.recv_overhead { - if let Some(old_recv_overhead) = prev_run_metadata.recv_overhead.get(location) { - println!( - "Location {:?}'s recv overhead changed from {} to {}", - location, old_recv_overhead, recv_overhead - ); - } - } -} diff --git a/hydro_optimize/src/rewrites.rs b/hydro_optimize/src/rewrites.rs index 507e268..b183246 100644 --- a/hydro_optimize/src/rewrites.rs +++ b/hydro_optimize/src/rewrites.rs @@ -37,12 +37,11 @@ pub type Rewrites = Vec; /// Returns Vec(Cluster, number of nodes) for each created cluster and a new FlowBuilder pub fn replay<'a>( rewrites: &mut Rewrites, - builder: FlowBuilder<'a>, + builder: &mut FlowBuilder<'a>, ir: &[HydroRoot], -) -> (Vec<(Cluster<'a, ()>, usize)>, FlowBuilder<'a>) { +) -> Vec<(Cluster<'a, ()>, usize)> { let mut new_clusters = vec![]; - let multi_run_metadata = RefCell::new(vec![]); let mut ir = deep_clone(ir); // Apply decoupling/partitioning in order @@ -51,7 +50,7 @@ pub fn replay<'a>( match &mut rewrite_metadata.rewrite { Rewrite::Decouple(decoupler) => { decoupler.decoupled_location = new_cluster.id().clone(); - decoupler::decouple(&mut ir, decoupler, &multi_run_metadata, 0); + decoupler::decouple(&mut ir, decoupler); } Rewrite::Partition(_partitioner) => { panic!("Partitioning is not yet replayable"); @@ -60,9 +59,9 @@ pub fn replay<'a>( new_clusters.push((new_cluster, rewrite_metadata.num_nodes)); } - builder.force_roots(ir); + builder.replace_ir(ir); - (new_clusters, builder) + new_clusters } /// Replace CLUSTER_SELF_ID with the ID of the original node the partition is assigned to diff --git a/hydro_optimize_examples/examples/benchmark_paxos.rs b/hydro_optimize_examples/examples/benchmark_paxos.rs index d294653..bc07736 100644 --- a/hydro_optimize_examples/examples/benchmark_paxos.rs +++ b/hydro_optimize_examples/examples/benchmark_paxos.rs @@ -4,7 +4,9 @@ use clap::{ArgAction, Parser}; use hydro_deploy::Deployment; use hydro_lang::location::Location; use hydro_optimize::deploy::{HostType, ReusableHosts}; -use hydro_optimize::deploy_and_analyze::deploy_and_optimize; +use hydro_optimize::deploy_and_analyze::{ + Optimizations, ReusableClusters, ReusableProcesses, deploy_and_optimize, +}; use hydro_test::cluster::kv_replica::Replica; use hydro_test::cluster::paxos::{Acceptor, CorePaxos, PaxosConfig, Proposer}; use hydro_test::cluster::paxos_bench::{Aggregator, Client}; @@ -54,7 +56,6 @@ async fn main() { let num_clients_per_node = vec![1, 50, 100]; let run_seconds = 30; - let multi_run_metadata = RefCell::new(vec![]); let mut iteration = 0; let max_num_clients_per_node = num_clients_per_node.iter().max().unwrap(); for (i, num_clients) in num_clients.iter().enumerate() { @@ -98,50 +99,21 @@ async fn main() { &replicas, ); - let clusters = vec![ - ( - proposers.id().key(), - std::any::type_name::().to_string(), - f + 1, - ), - ( - acceptors.id().key(), - std::any::type_name::().to_string(), - 2 * f + 1, - ), - ( - clients.id().key(), - std::any::type_name::().to_string(), - *num_clients, - ), - ( - replicas.id().key(), - std::any::type_name::().to_string(), - f + 1, - ), - ]; - let processes = vec![( - client_aggregator.id().key(), - std::any::type_name::().to_string(), - )]; - - let (rewritten_ir_builder, ir, _, _, _) = deploy_and_optimize( + deploy_and_optimize( &mut reusable_hosts, &mut deployment, builder.finalize(), - &clusters, - &processes, - vec![], + ReusableClusters::new() + .with_cluster(proposers, f + 1) + .with_cluster(acceptors, 2 * f + 1) + .with_cluster(clients, *num_clients) + .with_cluster(replicas, f + 1), + ReusableProcesses::new().with_process(client_aggregator), + Optimizations::new(), Some(run_seconds), - &multi_run_metadata, - iteration, ) .await; - // Cleanup and generate graphs if requested - let built = rewritten_ir_builder.build_with(|_| ir).finalize(); - _ = built.generate_graph_with_config(&args.graph, None); - iteration += 1; } } diff --git a/hydro_optimize_examples/examples/network_calibrator.rs b/hydro_optimize_examples/examples/network_calibrator.rs index ffa9952..07a1ffa 100644 --- a/hydro_optimize_examples/examples/network_calibrator.rs +++ b/hydro_optimize_examples/examples/network_calibrator.rs @@ -1,17 +1,13 @@ -use std::cell::RefCell; -use std::collections::HashMap; -use std::sync::Arc; - -use clap::Parser; +use clap::{ArgAction, Parser}; use hydro_deploy::Deployment; -use hydro_deploy::gcp::GcpNetwork; use hydro_lang::location::Location; use hydro_lang::prelude::FlowBuilder; use hydro_lang::viz::config::GraphConfig; -use hydro_optimize::deploy::ReusableHosts; -use hydro_optimize::deploy_and_analyze::deploy_and_optimize; +use hydro_optimize::deploy::{HostType, ReusableHosts}; +use hydro_optimize::deploy_and_analyze::{ + Optimizations, ReusableClusters, ReusableProcesses, deploy_and_optimize, +}; use hydro_optimize_examples::network_calibrator::{Aggregator, Client, Server, network_calibrator}; -use tokio::sync::RwLock; #[derive(Parser, Debug)] #[command(author, version, about, long_about = None, group( @@ -50,7 +46,6 @@ async fn main() { let num_clients_per_node = 1000; let message_sizes = vec![1, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192]; let num_seconds_to_profile = Some(60); - let multi_run_metadata = RefCell::new(vec![]); for message_size in message_sizes { let builder = FlowBuilder::new(); @@ -58,23 +53,6 @@ async fn main() { let clients = builder.cluster(); let client_aggregator = builder.process(); - let clusters = vec![ - ( - server.id().key(), - std::any::type_name::().to_string(), - 1, - ), - ( - clients.id().key(), - std::any::type_name::().to_string(), - num_clients, - ), - ]; - let processes = vec![( - client_aggregator.id().key(), - std::any::type_name::().to_string(), - )]; - println!( "Running network calibrator with message size: {} bytes, num clients: {}", message_size, num_clients @@ -87,25 +65,19 @@ async fn main() { &client_aggregator, ); - let (rewritten_ir_builder, ir, _, _, _) = deploy_and_optimize( + deploy_and_optimize( &mut reusable_hosts, &mut deployment, builder.finalize(), - &clusters, - &processes, - vec![ - std::any::type_name::().to_string(), - std::any::type_name::().to_string(), - ], + ReusableClusters::new() + .with_cluster(server, 1) + .with_cluster(clients, num_clients), + ReusableProcesses::new().with_process(client_aggregator), + Optimizations::new() + .excluding::() + .excluding::(), num_seconds_to_profile, - &multi_run_metadata, - 0, // Set to 0 to turn off comparisons between iterations ) .await; - - let built = rewritten_ir_builder.build_with(|_| ir).finalize(); - - // Generate graphs if requested - _ = built.generate_graph_with_config(&args.graph, None); } } diff --git a/hydro_optimize_examples/examples/partition_two_pc.rs b/hydro_optimize_examples/examples/partition_two_pc.rs index e978bef..deac5d3 100644 --- a/hydro_optimize_examples/examples/partition_two_pc.rs +++ b/hydro_optimize_examples/examples/partition_two_pc.rs @@ -5,7 +5,9 @@ use hydro_deploy::Deployment; use hydro_lang::location::Location; use hydro_lang::viz::config::GraphConfig; use hydro_optimize::deploy::{HostType, ReusableHosts}; -use hydro_optimize::deploy_and_analyze::deploy_and_optimize; +use hydro_optimize::deploy_and_analyze::{ + Optimizations, ReusableClusters, ReusableProcesses, deploy_and_optimize, +}; use hydro_test::cluster::two_pc::{Coordinator, Participant}; use hydro_test::cluster::two_pc_bench::{Aggregator, Client}; @@ -62,49 +64,21 @@ async fn main() { &client_aggregator, ); - let clusters = vec![ - ( - participants.id().key(), - std::any::type_name::().to_string(), - num_participants, - ), - ( - clients.id().key(), - std::any::type_name::().to_string(), - num_clients, - ), - ]; - let processes = vec![ - ( - coordinator.id().key(), - std::any::type_name::().to_string(), - ), - ( - client_aggregator.id().key(), - std::any::type_name::().to_string(), - ), - ]; - - let multi_run_metadata = RefCell::new(vec![]); - - let (rewritten_ir_builder, ir, _, _, _) = deploy_and_optimize( + deploy_and_optimize( &mut reusable_hosts, &mut deployment, builder.finalize(), - &clusters, - &processes, - vec![ - std::any::type_name::().to_string(), - std::any::type_name::().to_string(), - ], + ReusableClusters::new() + .with_cluster(participants, num_participants) + .with_cluster(clients, num_clients), + ReusableProcesses::new() + .with_process(coordinator) + .with_process(client_aggregator), + Optimizations::new() + .with_partitioning() + .excluding::() + .excluding::(), None, - &multi_run_metadata, - 0, ) .await; - - let built = rewritten_ir_builder.build_with(|_| ir).finalize(); - - // Generate graphs if requested - _ = built.generate_graph_with_config(&args.graph, None); } diff --git a/hydro_optimize_examples/examples/perf_paxos.rs b/hydro_optimize_examples/examples/perf_paxos.rs index 14930ab..62e9662 100644 --- a/hydro_optimize_examples/examples/perf_paxos.rs +++ b/hydro_optimize_examples/examples/perf_paxos.rs @@ -1,12 +1,11 @@ -use std::cell::RefCell; - use clap::{ArgAction, Parser}; use hydro_deploy::Deployment; use hydro_lang::location::Location; use hydro_lang::viz::config::GraphConfig; -use hydro_optimize::decoupler; use hydro_optimize::deploy::{HostType, ReusableHosts}; -use hydro_optimize::deploy_and_analyze::{Optimizations, deploy_and_optimize}; +use hydro_optimize::deploy_and_analyze::{ + Optimizations, ReusableClusters, ReusableProcesses, deploy_and_optimize, +}; use hydro_test::cluster::kv_replica::Replica; use hydro_test::cluster::paxos::{Acceptor, CorePaxos, PaxosConfig, Proposer}; use hydro_test::cluster::paxos_bench::{Aggregator, Client}; @@ -78,62 +77,27 @@ async fn main() { &replicas, ); - let mut clusters = vec![ - ( - proposers.id().key(), - std::any::type_name::().to_string(), - f + 1, - ), - ( - acceptors.id().key(), - std::any::type_name::().to_string(), - 2 * f + 1, - ), - ( - clients.id().key(), - std::any::type_name::().to_string(), - num_clients, - ), - ( - replicas.id().key(), - std::any::type_name::().to_string(), - f + 1, - ), - ]; - let processes = vec![( - client_aggregator.id().key(), - std::any::type_name::().to_string(), - )]; - // Deploy let mut reusable_hosts = ReusableHosts::new(host_type); - - let multi_run_metadata = RefCell::new(vec![]); let num_times_to_optimize = 2; - - for i in 0..num_times_to_optimize { - let new_builder = deploy_and_optimize( - &mut reusable_hosts, - &mut deployment, - builder.finalize(), - &mut clusters, - &processes, - vec![ - std::any::type_name::().to_string(), - std::any::type_name::().to_string(), - ], - Optimizations::new().with_decoupling(), - None, - &multi_run_metadata, - i, - ) - .await; - - builder = new_builder; - } - - let built = builder.finalize(); - - // Generate graphs if requested - _ = built.generate_graph_with_config(&args.graph, None); + let run_seconds = 30; + + deploy_and_optimize( + &mut reusable_hosts, + &mut deployment, + builder.finalize(), + ReusableClusters::new() + .with_cluster(proposers, f + 1) + .with_cluster(acceptors, 2 * f + 1) + .with_cluster(clients, num_clients) + .with_cluster(replicas, f + 1), + ReusableProcesses::new().with_process(client_aggregator), + Optimizations::new() + .with_decoupling() + .excluding::() + .excluding::() + .with_iterations(num_times_to_optimize), + Some(run_seconds), + ) + .await; } From 1c2ef73b04270842fd5ee05c41b5433f7ee64534 Mon Sep 17 00:00:00 2001 From: David Chu Date: Wed, 28 Jan 2026 16:00:07 -0800 Subject: [PATCH 19/35] lock server no compile errors! --- Cargo.lock | 22 ++-- Cargo.toml | 14 +- hydro_optimize_examples/src/lobsters.rs | 121 ++++++++++-------- hydro_optimize_examples/src/lock_server.rs | 100 +++++++-------- .../src/simple_kv_bench.rs | 4 +- 5 files changed, 132 insertions(+), 129 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index a673fca..3adee15 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -895,7 +895,7 @@ dependencies = [ [[package]] name = "copy_span" version = "0.1.0" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" +source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" dependencies = [ "proc-macro2", "syn", @@ -1114,7 +1114,7 @@ dependencies = [ [[package]] name = "dfir_lang" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" +source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" dependencies = [ "auto_impl", "documented", @@ -1780,7 +1780,7 @@ checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" [[package]] name = "hydro_build_utils" version = "0.0.1" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" +source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" dependencies = [ "insta", "rustc_version", @@ -1789,7 +1789,7 @@ dependencies = [ [[package]] name = "hydro_deploy" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" +source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" dependencies = [ "anyhow", "append-only-vec", @@ -1825,7 +1825,7 @@ dependencies = [ [[package]] name = "hydro_deploy_integration" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" +source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" dependencies = [ "async-recursion", "async-trait", @@ -1843,7 +1843,7 @@ dependencies = [ [[package]] name = "hydro_lang" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" +source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" dependencies = [ "auto_impl", "backtrace", @@ -1934,7 +1934,7 @@ dependencies = [ [[package]] name = "hydro_std" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" +source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" dependencies = [ "hdrhistogram", "hydro_lang", @@ -1946,7 +1946,7 @@ dependencies = [ [[package]] name = "hydro_test" version = "0.0.0" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" +source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" dependencies = [ "bytes", "colored", @@ -2156,7 +2156,7 @@ dependencies = [ [[package]] name = "include_mdtests" version = "0.0.0" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" +source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" dependencies = [ "glob", "proc-macro2", @@ -4005,7 +4005,7 @@ checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa" [[package]] name = "sinktools" version = "0.0.1" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" +source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" dependencies = [ "futures-util", "pin-project-lite", @@ -4789,7 +4789,7 @@ checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" [[package]] name = "variadics" version = "0.0.10" -source = "git+https://github.com/hydro-project/hydro.git?branch=david-fixes#29a0e22223a35cbfdbf58ea5ef8472c604662d8c" +source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" dependencies = [ "hashbrown 0.14.5", "hydro_build_utils", diff --git a/Cargo.toml b/Cargo.toml index e88fcab..e10b2b7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,13 +8,13 @@ members = [ resolver = "2" [workspace.dependencies] -hydro_lang = { version = "0.15.0", git = "https://github.com/hydro-project/hydro.git", branch = "david-fixes" } -hydro_std = { version = "0.15.0", git = "https://github.com/hydro-project/hydro.git", branch = "david-fixes" } -hydro_test = { version = "0.0.0", git = "https://github.com/hydro-project/hydro.git", branch = "david-fixes" } -dfir_lang = { version = "0.15.0", git = "https://github.com/hydro-project/hydro.git", branch = "david-fixes" } -hydro_build_utils = { version = "0.0.1", git = "https://github.com/hydro-project/hydro.git", branch = "david-fixes" } -hydro_deploy = { version = "0.15.0", git = "https://github.com/hydro-project/hydro.git", branch = "david-fixes", features = ["profile-folding"] } -include_mdtests = { version = "0.0.0", git = "https://github.com/hydro-project/hydro.git", branch = "david-fixes" } +hydro_lang = { version = "0.15.0", git = "https://github.com/hydro-project/hydro.git" } +hydro_std = { version = "0.15.0", git = "https://github.com/hydro-project/hydro.git" } +hydro_test = { version = "0.0.0", git = "https://github.com/hydro-project/hydro.git" } +dfir_lang = { version = "0.15.0", git = "https://github.com/hydro-project/hydro.git" } +hydro_build_utils = { version = "0.0.1", git = "https://github.com/hydro-project/hydro.git" } +hydro_deploy = { version = "0.15.0", git = "https://github.com/hydro-project/hydro.git", features = ["profile-folding"] } +include_mdtests = { version = "0.0.0", git = "https://github.com/hydro-project/hydro.git" } serde = { version = "1.0.197", features = ["derive"] } stageleft = "0.13.0" stageleft_tool = "0.13.0" diff --git a/hydro_optimize_examples/src/lobsters.rs b/hydro_optimize_examples/src/lobsters.rs index 29df1f1..a758a64 100644 --- a/hydro_optimize_examples/src/lobsters.rs +++ b/hydro_optimize_examples/src/lobsters.rs @@ -1,8 +1,11 @@ use hydro_lang::{ - live_collections::{sliced::sliced, stream::NoOrder}, + live_collections::{ + sliced::sliced, + stream::{NoOrder, TotalOrder}, + }, location::{Location, MemberId}, nondet::nondet, - prelude::{KeyedStream, Process, Unbounded}, + prelude::{Bounded, KeyedSingleton, KeyedStream, Process, Singleton, Stream, Unbounded}, }; use serde::{Deserialize, Serialize}; use sha2::{Digest, Sha256}; @@ -60,7 +63,7 @@ pub fn lobsters<'a, Client>( Unbounded, NoOrder, >, - _upvote_story: KeyedStream< + upvote_story: KeyedStream< MemberId, (u32, String, u32), Process<'a, Server>, @@ -74,7 +77,7 @@ pub fn lobsters<'a, Client>( Unbounded, NoOrder, >, - _get_stories: KeyedStream, u32, Process<'a, Server>, Unbounded, NoOrder>, + get_stories: KeyedStream, u32, Process<'a, Server>, Unbounded, NoOrder>, _get_comments: KeyedStream, u32, Process<'a, Server>, Unbounded, NoOrder>, _get_story_comments: KeyedStream< MemberId, @@ -89,64 +92,71 @@ pub fn lobsters<'a, Client>( let user_auth_tick = server.tick(); let stories_tick = server.tick(); - let atomic_add_user = add_user.atomic(&user_auth_tick); - // Persisted users - let curr_users = atomic_add_user + // Add users + let user_key_add_user = add_user .entries() - .map(q!(|(_client_id, (virtual_client_id, username))| ( + .map(q!(|(client_id, (virtual_client_id, username))| ( username.clone(), - (self::generate_api_key(username), virtual_client_id) + ( + self::generate_api_key(username), + client_id, + virtual_client_id + ) ))) - .into_keyed() + .into_keyed(); + let atomic_add_user = user_key_add_user.atomic(&user_auth_tick); + // Add story + let api_key_add_story = add_story + .entries() + .map(q!(|( + client_id, + (virtual_client_id, api_key, title, timestamp), + )| ( + api_key, + (client_id, virtual_client_id, title, timestamp) + ))) + .into_keyed(); + + // Persisted users + let curr_users = atomic_add_user .assume_ordering(nondet!(/** First user wins */)) .first(); - // Send response back to client. Only done after the tick to ensure that once the client gets the response, the user has been added - let add_user_response = sliced! { - let new_users = use(atomic_add_user, nondet!(/** New users requests this tick */)); - let curr_users = use(curr_users, nondet!(/** Current users this tick */)); - new_users - .map(q!(|(client_id, (username, api_key))| { - (username, (client_id, api_key)) - })) - .into_keyed() + // Anything to do with persisted users + let (add_user_response, get_users_response, add_story_valid_api_key) = sliced! { + let new_users = use::atomic(atomic_add_user, nondet!(/** New users requests this tick */)); + let get_users = use(get_users, nondet!(/** Order of processing affects which users will be retrieved */)); + let add_story = use(api_key_add_story, nondet!(/** Add story requests sent before user's creation will fail */)); + + let curr_users = use::atomic(curr_users, nondet!(/** Current users this tick */)); + let add_users_response = new_users; // TODO + let get_users_response = get_users.cross_singleton(curr_users.into_singleton()); + let add_story_valid_api_key = add_story; // TODO + (add_users_response, get_users_response, add_story_valid_api_key) }; - // Get users - let _get_users_response = get_users - .batch( - &user_auth_tick, - nondet!(/** Snapshot against current users */), - ) - .cross_singleton(curr_users_hashset) - .all_ticks(); + let valid_add_story = add_story_valid_api_key.values(); + // Anything to do with persisted stories + let (add_story_with_id, upvote_story_response, get_stories_response) = sliced! { + let add_story = use(valid_add_story, nondet!(/** Add new incoming story requests this tick */)); + let get_stories = use(get_stories, nondet!(/** Order of processing affects which stories will be retrieved */)); + // TODO: Replace with KeyedSingleton once that is supported + // ID, client_id, virtual_client_id, title, timestamp + let mut stories = use::state_null::, u32, String, Instant), _, Bounded, NoOrder>>(); + let mut next_story_id = use::state::>(|l| l.singleton(q!(0))); - // Add story - let add_story_pre_join = - add_story.map(q!(|(client_id, (req_id, api_key, title, timestamp))| { - (api_key, (client_id, req_id, title, timestamp)) - })); - let stories = add_story_pre_join - .batch( - &user_auth_tick, - nondet!(/** Compare against current users to approve/deny access */), - ) - .join(curr_users.clone()) - .all_ticks(); - let curr_stories = stories.batch(&stories_tick, nondet!(/** Snapshot of current stories */)).assume_ordering(nondet!(/** In order to use enumerate to assign a unique ID, we need total ordering. */)); - // Assign each story a unique ID - let (story_id_complete_cycle, story_id) = - stories_tick.cycle_with_initial(stories_tick.singleton(q!(0))); - let _indexed_curr_stories = curr_stories - .clone() - .enumerate() - .cross_singleton(story_id.clone()) - .map(q!(|((index, story), story_id)| (index + story_id, story))); - let num_curr_stories = curr_stories.clone().count(); - let new_story_id = num_curr_stories - .zip(story_id) - .map(q!(|(num_stories, story_id)| num_stories + story_id)); - story_id_complete_cycle.complete_next_tick(new_story_id); + let new_stories = add_story.clone().assume_ordering(nondet!(/** Stories are assigned an ID in arbitrary order */)) + .enumerate() + .cross_singleton(next_story_id) + .map(q!(|((index, (client_id, virtual_client_id, title, timestamp)), curr_id)| (index as u32 + curr_id, client_id, virtual_client_id, title, timestamp))); + next_story_id = next_story_id.zip(add_story.count()).map(q!(|(curr_id, count)| curr_id + count as u32)); + + stories. + + stories = stories.chain(new_stories); + + (new_stories, ) + }; let _top_stories = curr_stories.clone().persist().fold_commutative_idempotent( q!(|| vec![]), @@ -162,7 +172,10 @@ pub fn lobsters<'a, Client>( ), ); - (add_user_response,) + ( + add_user_response.end_atomic(), + get_users_response.end_atomic(), + ) } fn generate_api_key(email: String) -> String { diff --git a/hydro_optimize_examples/src/lock_server.rs b/hydro_optimize_examples/src/lock_server.rs index 9c3e767..da327e4 100644 --- a/hydro_optimize_examples/src/lock_server.rs +++ b/hydro_optimize_examples/src/lock_server.rs @@ -34,46 +34,47 @@ pub fn lock_server<'a, Client>( (client_id, virtual_client_id) ))) .into_keyed(); - let mapped_releases = releases + let atomic_releases = releases.atomic(&server_tick); + let mapped_releases = atomic_releases .clone() .entries() - .map(q!(|(client_id, (virtual_client_id, lock_id))| ( - lock_id, - (client_id, virtual_client_id) - ))) - .into_keyed(); + .map(q!(|(_client_id, (_virtual_client_id, lock_id))| lock_id)); - sliced! { + let acquire_results = sliced! { let mapped_acquires = use(mapped_acquires, nondet!(/** For each lock, pick a random acquire as the winner */)); - let mapped_releases = use(mapped_releases, nondet!(/** For each lock, only one release should succeed (the owner of the lock) */)); + let mapped_releases = use::atomic(mapped_releases, nondet!(/** For each lock, only one release should succeed (the owner of the lock) */)); // lock_id - let mut free_locks = use::state_null::>(); + // TODO: Replace with KeyedSingleton when support is added // (lock_id, (client_id, virtual_client_id)) - let mut acquired_locks = use::state_null::, u32)), _, _, _>>(); - let keyed_acquired_locks = acquired_locks.into_keyed().first(); - // For each lock, pick a random acquire as the winner + let mut acquired_locks = use::state_null::, u32)), _, _, NoOrder>>(); + let keyed_acquired_locks = acquired_locks.into_keyed().assume_ordering(nondet!(/** Actually KeyedSingleton */)).first(); - // Always process releases first - let new_free_locks = keyed_acquired_locks + // Always process releases first. Find out which locks still can't be acquired + let curr_acquired_locks = keyed_acquired_locks .clone() - .get_many_if_present(mapped_releases) - .filter(q!(|((holder_client_id, holder_virtual_client_id), (client_id, virtual_client_id))| - holder_client_id == client_id && holder_virtual_client_id == virtual_client_id - )) - .keys() - .chain(free_locks); + .filter_key_not_in(mapped_releases); // Only correct if non-lock holders don't release locks they don't own - let winning_acquires = mapped_acquires.assume_ordering(nondet!(/** Randomly pick one acquire to be the winner */)).first(); + // For each lock, pick a random acquire as the winner + let winning_acquires = mapped_acquires.clone().assume_ordering(nondet!(/** Randomly pick one acquire to be the winner */)).first(); - // Process acquires for locks that exist - // TODO: Requires join_stream + // Acquires win for all non-acquired locks, even ones that don't exist yet + let newly_acquired_locks = winning_acquires.filter_key_not_in(curr_acquired_locks.clone().keys()); + acquired_locks = curr_acquired_locks.entries().chain(newly_acquired_locks.clone().entries()); - // Create new locks if it's not currently free or acquired - let created_locks = winning_acquires - .filter_key_not_in(new_free_locks) - .filter_key_not_in(keyed_acquired_locks.keys()); - }; + let acquire_requests = mapped_acquires.entries().map(q!(|(lock_id, (client_id, virtual_client_id))| ((client_id, virtual_client_id), lock_id))).into_keyed(); + acquire_requests.lookup_keyed_singleton(newly_acquired_locks) + } + .entries() + .map(q!(|((client_id, virtual_client_id), (lock_id, curr_holder))| { + let lock_acquired = curr_holder.is_some_and(|(holder_client_id, holder_virtual_client_id)| { + holder_client_id == client_id && holder_virtual_client_id == virtual_client_id + }); + (client_id, (virtual_client_id, lock_id, lock_acquired)) + })) + .into_keyed(); + + (acquire_results, atomic_releases.end_atomic()) } /// Lock server implementation as described in https://dl.acm.org/doi/pdf/10.1145/3341301.3359651, with the difference being that each server can hold multiple locks. @@ -95,26 +96,27 @@ pub fn assume_order_lock_server<'a, Client>( KeyedStream, (u32, u32), Process<'a, Server>, Unbounded, NoOrder>, ) { let server_tick = server.tick(); - let atomic_acquires = acquires - .clone() + let atomic_acquires = acquires.atomic(&server_tick); + let lock_id_acquires = atomic_acquires .entries() .map(q!(|(client_id, (virtual_client_id, lock_id))| ( lock_id, (client_id, virtual_client_id, true) ))) - .atomic(&server_tick); - let atomic_releases = releases + .into_keyed(); + let atomic_releases = releases.atomic(&server_tick); + let lock_id_releases = atomic_releases .clone() .entries() .map(q!(|(client_id, (virtual_client_id, lock_id))| ( lock_id, (client_id, virtual_client_id, false) ))) - .atomic(&server_tick); - let payloads = atomic_acquires.interleave(atomic_releases).into_keyed(); + .into_keyed(); - let lock_state = payloads + let lock_state = lock_id_acquires .clone() + .interleave(lock_id_releases) .assume_ordering(nondet!(/** Process in arrival order */)) .fold( q!(|| None), @@ -138,34 +140,22 @@ pub fn assume_order_lock_server<'a, Client>( }), ); - // TODO + // Check if acquires succeeded let acquire_results = sliced! { - let payloads = use::atomic(payloads.clone(), nondet!(/** Payloads at this tick */)); + let acquires = use::atomic(lock_id_acquires, nondet!(/** Payloads at this tick */)); let locks_snapshot = use::atomic(lock_state, nondet!(/** Snapshot of lock state at this tick */)); - let acquires = payloads.filter(q!(|(_, _, acquire)| *acquire)); - locks_snapshot.get_many_if_present(acquires) + // Note: join_keyed_singleton is guaranteed to not miss, since an acquire/release must've been processed first + acquires.join_keyed_singleton(locks_snapshot) } - .map(q!(|(curr_holder, (client_id, virtual_client_id, _acquire))| { + .entries() + .map(q!(|(lock_id, ((client_id, virtual_client_id, _acquire), curr_holder))| { let lock_acquired = curr_holder.is_some_and(|(holder_client_id, holder_virtual_client_id)| { holder_client_id == client_id && holder_virtual_client_id == virtual_client_id }); - (client_id, virtual_client_id, lock_acquired) + (client_id, (virtual_client_id, lock_id, lock_acquired)) })) - .entries() - .map(q!(|(lock_id, (client_id, virtual_client_id, acquired))| (client_id, (virtual_client_id, lock_id, acquired)))) .into_keyed(); - let release_results = payloads - .end_atomic() - .entries() - .filter_map(q!(|(lock_id, (client_id, virtual_client_id, acquire))| { - if !acquire { - Some((client_id, (virtual_client_id, lock_id))) - } else { - None - } - })) - .into_keyed(); - (acquire_results, release_results) + (acquire_results, atomic_releases.end_atomic()) } diff --git a/hydro_optimize_examples/src/simple_kv_bench.rs b/hydro_optimize_examples/src/simple_kv_bench.rs index 3e7ba65..4a22a8e 100644 --- a/hydro_optimize_examples/src/simple_kv_bench.rs +++ b/hydro_optimize_examples/src/simple_kv_bench.rs @@ -72,7 +72,7 @@ mod tests { #[test] fn simple_kv_ir() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let kv = builder.process(); let clients = builder.cluster(); let client_aggregator = builder.process(); @@ -100,7 +100,7 @@ mod tests { #[tokio::test] async fn simple_kv_some_throughput() { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let kv = builder.process(); let clients = builder.cluster(); let client_aggregator = builder.process(); From 23183897aa3ac6b21354d1db7eaa4cda2e0f7999 Mon Sep 17 00:00:00 2001 From: David Chu Date: Wed, 28 Jan 2026 16:18:24 -0800 Subject: [PATCH 20/35] lock server doesn't need to distinguish between client_id and virtual_client_id --- hydro_optimize_examples/src/lobsters.rs | 19 +++-- hydro_optimize_examples/src/lock_server.rs | 91 ++++++++++------------ 2 files changed, 53 insertions(+), 57 deletions(-) diff --git a/hydro_optimize_examples/src/lobsters.rs b/hydro_optimize_examples/src/lobsters.rs index a758a64..cba374a 100644 --- a/hydro_optimize_examples/src/lobsters.rs +++ b/hydro_optimize_examples/src/lobsters.rs @@ -93,7 +93,9 @@ pub fn lobsters<'a, Client>( let stories_tick = server.tick(); // Add users - let user_key_add_user = add_user + let atomic_add_user = add_user.atomic(&user_auth_tick); + let user_key_add_user = atomic_add_user + .clone() .entries() .map(q!(|(client_id, (virtual_client_id, username))| ( username.clone(), @@ -104,7 +106,11 @@ pub fn lobsters<'a, Client>( ) ))) .into_keyed(); - let atomic_add_user = user_key_add_user.atomic(&user_auth_tick); + let add_user_request = atomic_add_user + .entries() + .map(q!(|(client_id, (virtual_client_id, username))| ((client_id, virtual_client_id), username))) + .into_keyed(); + // Add story let api_key_add_story = add_story .entries() @@ -118,20 +124,21 @@ pub fn lobsters<'a, Client>( .into_keyed(); // Persisted users - let curr_users = atomic_add_user + let curr_users = user_key_add_user .assume_ordering(nondet!(/** First user wins */)) .first(); // Anything to do with persisted users let (add_user_response, get_users_response, add_story_valid_api_key) = sliced! { - let new_users = use::atomic(atomic_add_user, nondet!(/** New users requests this tick */)); + let add_user = use::atomic(add_user_request, nondet!(/** New users requests this tick */)); let get_users = use(get_users, nondet!(/** Order of processing affects which users will be retrieved */)); let add_story = use(api_key_add_story, nondet!(/** Add story requests sent before user's creation will fail */)); let curr_users = use::atomic(curr_users, nondet!(/** Current users this tick */)); + let curr_api_keys = curr_users.entries().map(q!(|(_username, (api_key, _client_id, _virtual_client_id))| (api_key, ()))).into_keyed().assume_ordering(nondet!(/** Actually KeyedSingleton, assuming API key generation is unique */)).first(); - let add_users_response = new_users; // TODO + let add_users_response = add_user.lookup_keyed_singleton(curr_users); let get_users_response = get_users.cross_singleton(curr_users.into_singleton()); - let add_story_valid_api_key = add_story; // TODO + let add_story_valid_api_key = add_story.join_keyed_singleton(curr_api_keys); (add_users_response, get_users_response, add_story_valid_api_key) }; diff --git a/hydro_optimize_examples/src/lock_server.rs b/hydro_optimize_examples/src/lock_server.rs index da327e4..6e010c6 100644 --- a/hydro_optimize_examples/src/lock_server.rs +++ b/hydro_optimize_examples/src/lock_server.rs @@ -1,16 +1,17 @@ use hydro_lang::{ live_collections::{sliced::sliced, stream::NoOrder}, - location::{Location, MemberId}, + location::Location, nondet::nondet, prelude::{KeyedStream, Process, Stream, Unbounded}, }; use stageleft::q; +use std::hash::Hash; pub struct Server {} /// Lock server implementation as described in https://dl.acm.org/doi/pdf/10.1145/3341301.3359651, with the difference being that each server can hold multiple locks. -/// * `acquires`: Stream of (virt_client_id, lock_id), requesting a lock from the server. If the server currently holds the lock, it returns (virt_client_id, lock_id, true). Otherwise, it returns (virt_client_id, lock_id, false). -/// * `releases`: Stream of (virt_client_id, lock_id), releasing a lock back to the server. Returns (virt_client_id, lock_id). +/// * `acquires`: Stream of (client, lock_id), requesting a lock from the server. If the server currently holds the lock, it returns (client, lock_id, true). Otherwise, it returns (client, lock_id, false). +/// * `releases`: Stream of (client, lock_id), releasing a lock back to the server. Returns (client, lock_id). /// /// Assumptions: /// - No client will send a release message before it knows it has acquired the lock. @@ -19,26 +20,23 @@ pub struct Server {} #[expect(clippy::type_complexity, reason = "internal Lock Server code // TODO")] pub fn lock_server<'a, Client>( server: &Process<'a, Server>, - acquires: KeyedStream, (u32, u32), Process<'a, Server>, Unbounded, NoOrder>, - releases: KeyedStream, (u32, u32), Process<'a, Server>, Unbounded, NoOrder>, + acquires: KeyedStream, Unbounded, NoOrder>, + releases: KeyedStream, Unbounded, NoOrder>, ) -> ( - KeyedStream, (u32, u32, bool), Process<'a, Server>, Unbounded, NoOrder>, - KeyedStream, (u32, u32), Process<'a, Server>, Unbounded, NoOrder>, -) { + KeyedStream, Unbounded, NoOrder>, + KeyedStream, Unbounded, NoOrder>, +) +where + Client: Eq + Hash + Clone, +{ let server_tick = server.tick(); let mapped_acquires = acquires .clone() .entries() - .map(q!(|(client_id, (virtual_client_id, lock_id))| ( - lock_id, - (client_id, virtual_client_id) - ))) + .map(q!(|(client, lock_id)| (lock_id, client))) .into_keyed(); let atomic_releases = releases.atomic(&server_tick); - let mapped_releases = atomic_releases - .clone() - .entries() - .map(q!(|(_client_id, (_virtual_client_id, lock_id))| lock_id)); + let mapped_releases = atomic_releases.clone().values(); let acquire_results = sliced! { let mapped_acquires = use(mapped_acquires, nondet!(/** For each lock, pick a random acquire as the winner */)); @@ -47,7 +45,7 @@ pub fn lock_server<'a, Client>( // lock_id // TODO: Replace with KeyedSingleton when support is added // (lock_id, (client_id, virtual_client_id)) - let mut acquired_locks = use::state_null::, u32)), _, _, NoOrder>>(); + let mut acquired_locks = use::state_null::>(); let keyed_acquired_locks = acquired_locks.into_keyed().assume_ordering(nondet!(/** Actually KeyedSingleton */)).first(); // Always process releases first. Find out which locks still can't be acquired @@ -62,15 +60,13 @@ pub fn lock_server<'a, Client>( let newly_acquired_locks = winning_acquires.filter_key_not_in(curr_acquired_locks.clone().keys()); acquired_locks = curr_acquired_locks.entries().chain(newly_acquired_locks.clone().entries()); - let acquire_requests = mapped_acquires.entries().map(q!(|(lock_id, (client_id, virtual_client_id))| ((client_id, virtual_client_id), lock_id))).into_keyed(); + let acquire_requests = mapped_acquires.entries().map(q!(|(lock_id, client)| (client, lock_id))).into_keyed(); acquire_requests.lookup_keyed_singleton(newly_acquired_locks) } .entries() - .map(q!(|((client_id, virtual_client_id), (lock_id, curr_holder))| { - let lock_acquired = curr_holder.is_some_and(|(holder_client_id, holder_virtual_client_id)| { - holder_client_id == client_id && holder_virtual_client_id == virtual_client_id - }); - (client_id, (virtual_client_id, lock_id, lock_acquired)) + .map(q!(|(client, (lock_id, curr_holder))| { + let lock_acquired = curr_holder.is_some_and(|curr_client| client == curr_client); + (client, (lock_id, lock_acquired)) })) .into_keyed(); @@ -78,8 +74,8 @@ pub fn lock_server<'a, Client>( } /// Lock server implementation as described in https://dl.acm.org/doi/pdf/10.1145/3341301.3359651, with the difference being that each server can hold multiple locks. -/// * `acquires`: Stream of (virt_client_id, lock_id), requesting a lock from the server. If the server currently holds the lock, it returns (virt_client_id, lock_id, true). Otherwise, it returns (virt_client_id, lock_id, false). -/// * `releases`: Stream of (virt_client_id, lock_id), releasing a lock back to the server. Returns (virt_client_id, lock_id). +/// * `acquires`: Stream of (client, lock_id), requesting a lock from the server. If the server currently holds the lock, it returns (client, lock_id, true). Otherwise, it returns (client, lock_id, false). +/// * `releases`: Stream of (client, lock_id), releasing a lock back to the server. Returns (client, lock_id). /// /// Assumptions: /// - No client will send a release message before it knows it has acquired the lock. @@ -89,29 +85,26 @@ pub fn lock_server<'a, Client>( #[expect(clippy::type_complexity, reason = "internal Lock Server code // TODO")] pub fn assume_order_lock_server<'a, Client>( server: &Process<'a, Server>, - acquires: KeyedStream, (u32, u32), Process<'a, Server>, Unbounded, NoOrder>, - releases: KeyedStream, (u32, u32), Process<'a, Server>, Unbounded, NoOrder>, + acquires: KeyedStream, Unbounded, NoOrder>, + releases: KeyedStream, Unbounded, NoOrder>, ) -> ( - KeyedStream, (u32, u32, bool), Process<'a, Server>, Unbounded, NoOrder>, - KeyedStream, (u32, u32), Process<'a, Server>, Unbounded, NoOrder>, -) { + KeyedStream, Unbounded, NoOrder>, + KeyedStream, Unbounded, NoOrder>, +) +where + Client: Eq + Hash + Clone, +{ let server_tick = server.tick(); let atomic_acquires = acquires.atomic(&server_tick); let lock_id_acquires = atomic_acquires .entries() - .map(q!(|(client_id, (virtual_client_id, lock_id))| ( - lock_id, - (client_id, virtual_client_id, true) - ))) + .map(q!(|(client, lock_id)| (lock_id, (client, true)))) .into_keyed(); let atomic_releases = releases.atomic(&server_tick); let lock_id_releases = atomic_releases .clone() .entries() - .map(q!(|(client_id, (virtual_client_id, lock_id))| ( - lock_id, - (client_id, virtual_client_id, false) - ))) + .map(q!(|(client, lock_id)| (lock_id, (client, false)))) .into_keyed(); let lock_state = lock_id_acquires @@ -120,21 +113,19 @@ pub fn assume_order_lock_server<'a, Client>( .assume_ordering(nondet!(/** Process in arrival order */)) .fold( q!(|| None), - q!(|curr_holder, (client_id, virtual_client_id, acquire)| { + q!(|curr_holder, (client, acquire)| { if acquire { // If the lock is currently held by the server, give the client the lock if curr_holder.is_none() { - *curr_holder = Some((client_id.clone(), virtual_client_id.clone())); + *curr_holder = Some(client.clone()); } } else { // If the client is releasing the lock and it holds it, give the lock back to the server - if let Some((holder_client_id, holder_virtual_client_id)) = curr_holder.as_ref() + if curr_holder + .as_ref() + .is_some_and(|curr_client| client == *curr_client) { - if *holder_client_id == client_id - && *holder_virtual_client_id == virtual_client_id - { - *curr_holder = None; - } + *curr_holder = None; } } }), @@ -149,11 +140,9 @@ pub fn assume_order_lock_server<'a, Client>( acquires.join_keyed_singleton(locks_snapshot) } .entries() - .map(q!(|(lock_id, ((client_id, virtual_client_id, _acquire), curr_holder))| { - let lock_acquired = curr_holder.is_some_and(|(holder_client_id, holder_virtual_client_id)| { - holder_client_id == client_id && holder_virtual_client_id == virtual_client_id - }); - (client_id, (virtual_client_id, lock_id, lock_acquired)) + .map(q!(|(lock_id, ((client, _acquire), curr_holder))| { + let lock_acquired = curr_holder.is_some_and(|curr_client| client == curr_client); + (client, (lock_id, lock_acquired)) })) .into_keyed(); From 1ba7cd313a94c0156a3697756a7799b500ba80dd Mon Sep 17 00:00:00 2001 From: David Chu Date: Thu, 29 Jan 2026 11:50:42 -0800 Subject: [PATCH 21/35] perf_paxos compiles --- Cargo.lock | 38 +++---- hydro_optimize/src/deploy_and_analyze.rs | 8 +- hydro_optimize/src/parse_results.rs | 8 +- .../examples/benchmark_paxos.rs | 2 +- .../examples/network_calibrator.rs | 2 +- .../examples/partition_two_pc.rs | 2 +- .../examples/perf_paxos.rs | 6 +- hydro_optimize_examples/src/lib.rs | 4 +- hydro_optimize_examples/src/lobsters.rs | 105 ++++++++---------- 9 files changed, 80 insertions(+), 95 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 3adee15..e6da0be 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -739,9 +739,9 @@ dependencies = [ [[package]] name = "clap" -version = "4.5.55" +version = "4.5.56" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3e34525d5bbbd55da2bb745d34b36121baac88d07619a9a09cfcf4a6c0832785" +checksum = "a75ca66430e33a14957acc24c5077b503e7d374151b2b4b3a10c83b4ceb4be0e" dependencies = [ "clap_builder", "clap_derive", @@ -749,9 +749,9 @@ dependencies = [ [[package]] name = "clap_builder" -version = "4.5.55" +version = "4.5.56" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "59a20016a20a3da95bef50ec7238dbd09baeef4311dcdd38ec15aba69812fb61" +checksum = "793207c7fa6300a0608d1080b858e5fdbe713cdc1c8db9fb17777d8a13e63df0" dependencies = [ "anstream", "anstyle", @@ -895,7 +895,7 @@ dependencies = [ [[package]] name = "copy_span" version = "0.1.0" -source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" +source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" dependencies = [ "proc-macro2", "syn", @@ -1114,7 +1114,7 @@ dependencies = [ [[package]] name = "dfir_lang" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" +source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" dependencies = [ "auto_impl", "documented", @@ -1780,7 +1780,7 @@ checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" [[package]] name = "hydro_build_utils" version = "0.0.1" -source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" +source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" dependencies = [ "insta", "rustc_version", @@ -1789,7 +1789,7 @@ dependencies = [ [[package]] name = "hydro_deploy" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" +source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" dependencies = [ "anyhow", "append-only-vec", @@ -1825,7 +1825,7 @@ dependencies = [ [[package]] name = "hydro_deploy_integration" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" +source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" dependencies = [ "async-recursion", "async-trait", @@ -1843,7 +1843,7 @@ dependencies = [ [[package]] name = "hydro_lang" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" +source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" dependencies = [ "auto_impl", "backtrace", @@ -1934,7 +1934,7 @@ dependencies = [ [[package]] name = "hydro_std" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" +source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" dependencies = [ "hdrhistogram", "hydro_lang", @@ -1946,7 +1946,7 @@ dependencies = [ [[package]] name = "hydro_test" version = "0.0.0" -source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" +source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" dependencies = [ "bytes", "colored", @@ -2156,7 +2156,7 @@ dependencies = [ [[package]] name = "include_mdtests" version = "0.0.0" -source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" +source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" dependencies = [ "glob", "proc-macro2", @@ -4005,7 +4005,7 @@ checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa" [[package]] name = "sinktools" version = "0.0.1" -source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" +source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" dependencies = [ "futures-util", "pin-project-lite", @@ -4789,7 +4789,7 @@ checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" [[package]] name = "variadics" version = "0.0.10" -source = "git+https://github.com/hydro-project/hydro.git#30167649b29b1c199a14daabc796950d1a588297" +source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" dependencies = [ "hashbrown 0.14.5", "hydro_build_utils", @@ -5429,18 +5429,18 @@ dependencies = [ [[package]] name = "zerocopy" -version = "0.8.35" +version = "0.8.36" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fdea86ddd5568519879b8187e1cf04e24fce28f7fe046ceecbce472ff19a2572" +checksum = "dafd85c832c1b68bbb4ec0c72c7f6f4fc5179627d2bc7c26b30e4c0cc11e76cc" dependencies = [ "zerocopy-derive", ] [[package]] name = "zerocopy-derive" -version = "0.8.35" +version = "0.8.36" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c15e1b46eff7c6c91195752e0eeed8ef040e391cdece7c25376957d5f15df22" +checksum = "7cb7e4e8436d9db52fbd6625dbf2f45243ab84994a72882ec8227b99e72b439a" dependencies = [ "proc-macro2", "quote", diff --git a/hydro_optimize/src/deploy_and_analyze.rs b/hydro_optimize/src/deploy_and_analyze.rs index 5a70e1a..592db04 100644 --- a/hydro_optimize/src/deploy_and_analyze.rs +++ b/hydro_optimize/src/deploy_and_analyze.rs @@ -118,15 +118,15 @@ async fn track_cluster_usage_cardinality( for (idx, node) in cluster.members().iter().enumerate() { let (node_usage_out, node_cardinality_out) = track_process_usage_cardinality(node).await; - usage_out.insert((id.clone(), name.clone(), idx), node_usage_out); - cardinality_out.insert((id.clone(), name.clone(), idx), node_cardinality_out); + usage_out.insert((id.clone(), name.to_string(), idx), node_usage_out); + cardinality_out.insert((id.clone(), name.to_string(), idx), node_cardinality_out); } } for (id, name, process) in nodes.get_all_processes() { let (process_usage_out, process_cardinality_out) = track_process_usage_cardinality(process).await; - usage_out.insert((id.clone(), name.clone(), 0), process_usage_out); - cardinality_out.insert((id.clone(), name.clone(), 0), process_cardinality_out); + usage_out.insert((id.clone(), name.to_string(), 0), process_usage_out); + cardinality_out.insert((id.clone(), name.to_string(), 0), process_cardinality_out); } (usage_out, cardinality_out) } diff --git a/hydro_optimize/src/parse_results.rs b/hydro_optimize/src/parse_results.rs index cf053f0..9b93875 100644 --- a/hydro_optimize/src/parse_results.rs +++ b/hydro_optimize/src/parse_results.rs @@ -231,7 +231,7 @@ pub async fn analyze_cluster_results( let mut max_usage = None; for (idx, _) in cluster.members().iter().enumerate() { let usage = - get_usage(usage_out.get_mut(&(id.clone(), name.clone(), idx)).unwrap()).await; + get_usage(usage_out.get_mut(&(id.clone(), name.to_string(), idx)).unwrap()).await; println!("Node {} usage: {}", idx, usage); if let Some((prev_usage, _)) = max_usage { if usage > prev_usage { @@ -245,7 +245,7 @@ pub async fn analyze_cluster_results( if let Some((usage, idx)) = max_usage { // Modify IR with perf & cardinality numbers let node_cardinality = cardinality_out - .get_mut(&(id.clone(), name.clone(), idx)) + .get_mut(&(id.clone(), name.to_string(), idx)) .unwrap(); let unidentified_perf = analyze_process_results( cluster.members().get(idx).unwrap(), @@ -261,9 +261,9 @@ pub async fn analyze_cluster_results( .insert(id.clone(), unidentified_perf); // Update cluster with max usage - if max_usage_overall < usage && !exclude.contains(&name) { + if max_usage_overall < usage && !exclude.contains(&name.to_string()) { max_usage_cluster_id = Some(id); - max_usage_cluster_name = name.clone(); + max_usage_cluster_name = name.to_string(); max_usage_cluster_size = cluster.members().len(); max_usage_overall = usage; println!("The bottleneck is {}", name); diff --git a/hydro_optimize_examples/examples/benchmark_paxos.rs b/hydro_optimize_examples/examples/benchmark_paxos.rs index bc07736..162d072 100644 --- a/hydro_optimize_examples/examples/benchmark_paxos.rs +++ b/hydro_optimize_examples/examples/benchmark_paxos.rs @@ -72,7 +72,7 @@ async fn main() { num_clients, num_clients_per_node, run_seconds ); - let builder = hydro_lang::compile::builder::FlowBuilder::new(); + let mut builder = hydro_lang::compile::builder::FlowBuilder::new(); let proposers = builder.cluster(); let acceptors = builder.cluster(); let clients = builder.cluster(); diff --git a/hydro_optimize_examples/examples/network_calibrator.rs b/hydro_optimize_examples/examples/network_calibrator.rs index 07a1ffa..98eb6ce 100644 --- a/hydro_optimize_examples/examples/network_calibrator.rs +++ b/hydro_optimize_examples/examples/network_calibrator.rs @@ -48,7 +48,7 @@ async fn main() { let num_seconds_to_profile = Some(60); for message_size in message_sizes { - let builder = FlowBuilder::new(); + let mut builder = FlowBuilder::new(); let server = builder.cluster(); let clients = builder.cluster(); let client_aggregator = builder.process(); diff --git a/hydro_optimize_examples/examples/partition_two_pc.rs b/hydro_optimize_examples/examples/partition_two_pc.rs index deac5d3..e491805 100644 --- a/hydro_optimize_examples/examples/partition_two_pc.rs +++ b/hydro_optimize_examples/examples/partition_two_pc.rs @@ -45,7 +45,7 @@ async fn main() { let mut reusable_hosts = ReusableHosts::new(host_type); - let builder = hydro_lang::compile::builder::FlowBuilder::new(); + let mut builder = hydro_lang::compile::builder::FlowBuilder::new(); let num_participants = 3; let num_clients = 3; let num_clients_per_node = 100; diff --git a/hydro_optimize_examples/examples/perf_paxos.rs b/hydro_optimize_examples/examples/perf_paxos.rs index 62e9662..4f81a0d 100644 --- a/hydro_optimize_examples/examples/perf_paxos.rs +++ b/hydro_optimize_examples/examples/perf_paxos.rs @@ -1,13 +1,11 @@ use clap::{ArgAction, Parser}; use hydro_deploy::Deployment; -use hydro_lang::location::Location; use hydro_lang::viz::config::GraphConfig; use hydro_optimize::deploy::{HostType, ReusableHosts}; use hydro_optimize::deploy_and_analyze::{ Optimizations, ReusableClusters, ReusableProcesses, deploy_and_optimize, }; -use hydro_test::cluster::kv_replica::Replica; -use hydro_test::cluster::paxos::{Acceptor, CorePaxos, PaxosConfig, Proposer}; +use hydro_test::cluster::paxos::{CorePaxos, PaxosConfig}; use hydro_test::cluster::paxos_bench::{Aggregator, Client}; #[derive(Parser, Debug)] @@ -45,7 +43,7 @@ async fn main() { let mut builder = hydro_lang::compile::builder::FlowBuilder::new(); let f = 1; let num_clients = 3; - let num_clients_per_node = 500; // Change based on experiment between 1, 50, 100. + let num_clients_per_node = 100; // Change based on experiment between 1, 50, 100. let checkpoint_frequency = 1000; // Num log entries let i_am_leader_send_timeout = 5; // Sec let i_am_leader_check_timeout = 10; // Sec diff --git a/hydro_optimize_examples/src/lib.rs b/hydro_optimize_examples/src/lib.rs index 624b954..01b5ce3 100644 --- a/hydro_optimize_examples/src/lib.rs +++ b/hydro_optimize_examples/src/lib.rs @@ -3,8 +3,8 @@ stageleft::stageleft_no_entry_crate!(); pub mod network_calibrator; pub mod simple_kv_bench; pub mod lock_server; -pub mod lobsters; -pub mod web_submit; +// pub mod lobsters; +// pub mod web_submit; #[cfg(test)] mod test_init { diff --git a/hydro_optimize_examples/src/lobsters.rs b/hydro_optimize_examples/src/lobsters.rs index cba374a..e72eb3f 100644 --- a/hydro_optimize_examples/src/lobsters.rs +++ b/hydro_optimize_examples/src/lobsters.rs @@ -10,6 +10,7 @@ use hydro_lang::{ use serde::{Deserialize, Serialize}; use sha2::{Digest, Sha256}; use stageleft::q; +use std::{collections::HashMap, hash::Hash}; use tokio::time::Instant; pub struct Server {} @@ -47,48 +48,34 @@ impl PartialOrd for Story { )] pub fn lobsters<'a, Client>( server: &Process<'a, Server>, - add_user: KeyedStream, (u32, String), Process<'a, Server>, Unbounded, NoOrder>, - get_users: KeyedStream, u32, Process<'a, Server>, Unbounded, NoOrder>, + add_user: KeyedStream, Unbounded, NoOrder>, + get_users: Stream, Unbounded, NoOrder>, add_story: KeyedStream< - MemberId, - (u32, String, String, Instant), + Client, + (String, String, Instant), Process<'a, Server>, Unbounded, NoOrder, >, _add_comment: KeyedStream< - MemberId, - (u32, String, u32, String, Instant), - Process<'a, Server>, - Unbounded, - NoOrder, - >, - upvote_story: KeyedStream< - MemberId, - (u32, String, u32), - Process<'a, Server>, - Unbounded, - NoOrder, - >, - _upvote_comment: KeyedStream< - MemberId, - (u32, String, u32), - Process<'a, Server>, - Unbounded, - NoOrder, - >, - get_stories: KeyedStream, u32, Process<'a, Server>, Unbounded, NoOrder>, - _get_comments: KeyedStream, u32, Process<'a, Server>, Unbounded, NoOrder>, - _get_story_comments: KeyedStream< - MemberId, - (u32, u32), + Client, + (String, u32, String, Instant), Process<'a, Server>, Unbounded, NoOrder, >, + upvote_story: KeyedStream, Unbounded, NoOrder>, + _upvote_comment: KeyedStream, Unbounded, NoOrder>, + get_stories: Stream, Unbounded, NoOrder>, + _get_comments: Stream, Unbounded, NoOrder>, + _get_story_comments: KeyedStream, Unbounded, NoOrder>, ) -> ( - KeyedStream, (u32, Option), Process<'a, Server>, Unbounded, NoOrder>, // add_user response -) { + KeyedStream, Process<'a, Server>, Unbounded, NoOrder>, // add_user response + KeyedStream, Process<'a, Server>, Unbounded, NoOrder>, // get_users response +) +where + Client: Eq + Hash + Clone, +{ let user_auth_tick = server.tick(); let stories_tick = server.tick(); @@ -97,44 +84,33 @@ pub fn lobsters<'a, Client>( let user_key_add_user = atomic_add_user .clone() .entries() - .map(q!(|(client_id, (virtual_client_id, username))| ( + .map(q!(|(client, username)| ( username.clone(), - ( - self::generate_api_key(username), - client_id, - virtual_client_id - ) + (self::generate_api_key(username), client,) ))) .into_keyed(); - let add_user_request = atomic_add_user - .entries() - .map(q!(|(client_id, (virtual_client_id, username))| ((client_id, virtual_client_id), username))) - .into_keyed(); - + // Add story let api_key_add_story = add_story .entries() - .map(q!(|( - client_id, - (virtual_client_id, api_key, title, timestamp), - )| ( + .map(q!(|(client, (api_key, title, timestamp))| ( api_key, - (client_id, virtual_client_id, title, timestamp) + (client, title, timestamp) ))) .into_keyed(); // Persisted users - let curr_users = user_key_add_user + let curr_users = user_key_add_user .assume_ordering(nondet!(/** First user wins */)) .first(); // Anything to do with persisted users let (add_user_response, get_users_response, add_story_valid_api_key) = sliced! { - let add_user = use::atomic(add_user_request, nondet!(/** New users requests this tick */)); + let add_user = use::atomic(atomic_add_user, nondet!(/** New users requests this tick */)); let get_users = use(get_users, nondet!(/** Order of processing affects which users will be retrieved */)); let add_story = use(api_key_add_story, nondet!(/** Add story requests sent before user's creation will fail */)); let curr_users = use::atomic(curr_users, nondet!(/** Current users this tick */)); - let curr_api_keys = curr_users.entries().map(q!(|(_username, (api_key, _client_id, _virtual_client_id))| (api_key, ()))).into_keyed().assume_ordering(nondet!(/** Actually KeyedSingleton, assuming API key generation is unique */)).first(); + let curr_api_keys = curr_users.entries().map(q!(|(_username, (api_key, _client))| (api_key, ()))).into_keyed().assume_ordering(nondet!(/** Actually KeyedSingleton, assuming API key generation is unique */)).first(); let add_users_response = add_user.lookup_keyed_singleton(curr_users); let get_users_response = get_users.cross_singleton(curr_users.into_singleton()); @@ -142,24 +118,28 @@ pub fn lobsters<'a, Client>( (add_users_response, get_users_response, add_story_valid_api_key) }; - let valid_add_story = add_story_valid_api_key.values(); + let valid_add_story = + add_story_valid_api_key + .entries() + .map(q!(|(_api_key, ((client, title, timestamp), _))| ( + client, title, timestamp + ))); // Anything to do with persisted stories let (add_story_with_id, upvote_story_response, get_stories_response) = sliced! { let add_story = use(valid_add_story, nondet!(/** Add new incoming story requests this tick */)); let get_stories = use(get_stories, nondet!(/** Order of processing affects which stories will be retrieved */)); + let upvote_story = use(upvote_story, nondet!(/** If a story didn't exist when the upvote was sent, it will fail */)); // TODO: Replace with KeyedSingleton once that is supported - // ID, client_id, virtual_client_id, title, timestamp - let mut stories = use::state_null::, u32, String, Instant), _, Bounded, NoOrder>>(); + // ID, client, virtual_client, title, timestamp + let mut stories = use::state_null::>(); let mut next_story_id = use::state::>(|l| l.singleton(q!(0))); let new_stories = add_story.clone().assume_ordering(nondet!(/** Stories are assigned an ID in arbitrary order */)) .enumerate() .cross_singleton(next_story_id) - .map(q!(|((index, (client_id, virtual_client_id, title, timestamp)), curr_id)| (index as u32 + curr_id, client_id, virtual_client_id, title, timestamp))); + .map(q!(|((index, (client, title, timestamp)), curr_id)| (index as u32 + curr_id, client, title, timestamp))); next_story_id = next_story_id.zip(add_story.count()).map(q!(|(curr_id, count)| curr_id + count as u32)); - stories. - stories = stories.chain(new_stories); (new_stories, ) @@ -168,7 +148,7 @@ pub fn lobsters<'a, Client>( let _top_stories = curr_stories.clone().persist().fold_commutative_idempotent( q!(|| vec![]), q!( - |vec, (_api_key, ((_client_id, _req_id, title, timestamp), username))| { + |vec, (_api_key, ((_client, _req_id, title, timestamp), username))| { let new_elem = (title, timestamp, username); // TODO: Use a binary heap // TODO: Create a struct that is ordered by timestamp @@ -180,8 +160,15 @@ pub fn lobsters<'a, Client>( ); ( - add_user_response.end_atomic(), - get_users_response.end_atomic(), + add_user_response.map_with_key(q!(|(client, (username, user_with_that_name))| { + let (api_key, client_with_that_name) = user_with_that_name.unwrap(); + if client == client_with_that_name { + Some(api_key) + } else { + None + } + })), + get_users_response.into_keyed(), ) } From d4ae9f284a3d9288d6709d801ae606ad68789913 Mon Sep 17 00:00:00 2001 From: David Chu Date: Thu, 29 Jan 2026 13:46:28 -0800 Subject: [PATCH 22/35] Seeing if network metrics work --- Cargo.toml | 13 ++++- hydro_optimize/src/deploy_and_analyze.rs | 49 +++++++++---------- hydro_optimize/src/parse_results.rs | 32 +++++++----- .../examples/benchmark_paxos.rs | 9 +--- .../examples/network_calibrator.rs | 3 +- .../examples/partition_two_pc.rs | 3 -- 6 files changed, 57 insertions(+), 52 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index e10b2b7..37ee4b3 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -21,4 +21,15 @@ stageleft_tool = "0.13.0" tokio = { version = "1.29.0", features = ["full"] } ctor = "0.2" clap = { version = "4.4", features = ["derive"] } -regex = "1.11.1" \ No newline at end of file +regex = "1.11.1" + + +# Uncomment to use local hydroflow checkout (change path as needed) +# [patch."https://github.com/hydro-project/hydro.git"] +# hydro_lang = { path = "/local/home/chudc/hydroflow/hydro_lang" } +# hydro_std = { path = "/local/home/chudc/hydroflow/hydro_std" } +# hydro_test = { path = "/local/home/chudc/hydroflow/hydro_test" } +# dfir_lang = { path = "/local/home/chudc/hydroflow/dfir_lang" } +# hydro_build_utils = { path = "/local/home/chudc/hydroflow/hydro_build_utils" } +# hydro_deploy = { path = "/local/home/chudc/hydroflow/hydro_deploy/core" } +# include_mdtests = { path = "/local/home/chudc/hydroflow/include_mdtests" } \ No newline at end of file diff --git a/hydro_optimize/src/deploy_and_analyze.rs b/hydro_optimize/src/deploy_and_analyze.rs index 592db04..46df156 100644 --- a/hydro_optimize/src/deploy_and_analyze.rs +++ b/hydro_optimize/src/deploy_and_analyze.rs @@ -22,6 +22,7 @@ use crate::repair::{cycle_source_to_sink_input, inject_id, remove_counter}; const COUNTER_PREFIX: &str = "_optimize_counter"; pub(crate) const CPU_USAGE_PREFIX: &str = "HYDRO_OPTIMIZE_CPU:"; +pub(crate) const NETWORK_USAGE_PREFIX: &str = "HYDRO_OPTIMIZE_NET:"; // Note: Ensure edits to the match arms are consistent with inject_count_node fn insert_counter_node(node: &mut HydroNode, next_stmt_id: &mut usize, duration: syn::Expr) { @@ -97,38 +98,35 @@ fn insert_counter(ir: &mut [HydroRoot], duration: &syn::Expr) { ); } -async fn track_process_usage_cardinality( - process: &impl DeployCrateWrapper, -) -> (UnboundedReceiver, UnboundedReceiver) { - ( - process.stdout_filter(CPU_USAGE_PREFIX), - process.stdout_filter(COUNTER_PREFIX), - ) +pub struct Metrics { + pub cpu: UnboundedReceiver, + pub network: UnboundedReceiver, + pub counters: UnboundedReceiver, } -async fn track_cluster_usage_cardinality( +async fn track_process_metrics(process: &impl DeployCrateWrapper) -> Metrics { + Metrics { + cpu: process.stdout_filter(CPU_USAGE_PREFIX), + network: process.stdout_filter(NETWORK_USAGE_PREFIX), + counters: process.stdout_filter(COUNTER_PREFIX), + } +} + +async fn track_cluster_metrics( nodes: &DeployResult<'_, HydroDeploy>, -) -> ( - HashMap<(LocationId, String, usize), UnboundedReceiver>, - HashMap<(LocationId, String, usize), UnboundedReceiver>, -) { - let mut usage_out = HashMap::new(); - let mut cardinality_out = HashMap::new(); +) -> HashMap<(LocationId, String, usize), Metrics> { + let mut cluster_to_metrics = HashMap::new(); for (id, name, cluster) in nodes.get_all_clusters() { for (idx, node) in cluster.members().iter().enumerate() { - let (node_usage_out, node_cardinality_out) = - track_process_usage_cardinality(node).await; - usage_out.insert((id.clone(), name.to_string(), idx), node_usage_out); - cardinality_out.insert((id.clone(), name.to_string(), idx), node_cardinality_out); + let metrics = track_process_metrics(node).await; + cluster_to_metrics.insert((id.clone(), name.to_string(), idx), metrics); } } for (id, name, process) in nodes.get_all_processes() { - let (process_usage_out, process_cardinality_out) = - track_process_usage_cardinality(process).await; - usage_out.insert((id.clone(), name.to_string(), 0), process_usage_out); - cardinality_out.insert((id.clone(), name.to_string(), 0), process_cardinality_out); + let metrics = track_process_metrics(process).await; + cluster_to_metrics.insert((id.clone(), name.to_string(), 0), metrics); } - (usage_out, cardinality_out) + cluster_to_metrics } struct ScriptSidecar { @@ -294,7 +292,7 @@ pub async fn deploy_and_optimize<'a>( .deploy(deployment); deployment.deploy().await.unwrap(); - let (mut usage_out, mut cardinality_out) = track_cluster_usage_cardinality(&nodes).await; + let metrics = track_cluster_metrics(&nodes).await; // Wait for user to input a newline deployment @@ -321,8 +319,7 @@ pub async fn deploy_and_optimize<'a>( let (bottleneck, bottleneck_name, bottleneck_num_nodes) = analyze_cluster_results( &nodes, &mut ir, - &mut usage_out, - &mut cardinality_out, + metrics, &mut run_metadata, &optimizations.exclude, ) diff --git a/hydro_optimize/src/parse_results.rs b/hydro_optimize/src/parse_results.rs index 9b93875..0928fa6 100644 --- a/hydro_optimize/src/parse_results.rs +++ b/hydro_optimize/src/parse_results.rs @@ -1,15 +1,15 @@ use std::collections::HashMap; use hydro_lang::compile::deploy::DeployResult; -use hydro_lang::compile::ir::{ - HydroNode, HydroRoot, traverse_dfir, -}; +use hydro_lang::compile::ir::{HydroNode, HydroRoot, traverse_dfir}; use hydro_lang::deploy::HydroDeploy; use hydro_lang::deploy::deploy_graph::DeployCrateWrapper; use hydro_lang::location::dynamic::LocationId; use regex::Regex; use tokio::sync::mpsc::UnboundedReceiver; +use crate::deploy_and_analyze::Metrics; + #[derive(Default)] pub struct RunMetadata { pub send_overhead: HashMap, @@ -193,7 +193,7 @@ pub async fn analyze_process_results( process: &impl DeployCrateWrapper, ir: &mut [HydroRoot], op_to_count: &mut HashMap, - node_cardinality: &mut UnboundedReceiver, + metrics: &mut Metrics, ) -> f64 { let underlying = process.underlying(); let perf_results = underlying.tracing_results().unwrap(); @@ -202,10 +202,13 @@ pub async fn analyze_process_results( let unidentified_usage = inject_perf(ir, perf_results.folded_data.clone()); // Get cardinality data. Allow later values to overwrite earlier ones - while let Some(measurement) = node_cardinality.recv().await { + while let Some(measurement) = metrics.counters.recv().await { let (op_id, count) = parse_counter_usage(measurement.clone()); op_to_count.insert(op_id, count); } + while let Some(network_usage) = metrics.network.recv().await { + println!("Network: {}", network_usage); + } unidentified_usage } @@ -213,8 +216,7 @@ pub async fn analyze_process_results( pub async fn analyze_cluster_results( nodes: &DeployResult<'_, HydroDeploy>, ir: &mut [HydroRoot], - usage_out: &mut HashMap<(LocationId, String, usize), UnboundedReceiver>, - cardinality_out: &mut HashMap<(LocationId, String, usize), UnboundedReceiver>, + mut cluster_metrics: HashMap<(LocationId, String, usize), Metrics>, run_metadata: &mut RunMetadata, exclude: &Vec, ) -> (LocationId, String, usize) { @@ -223,15 +225,20 @@ pub async fn analyze_cluster_results( let mut max_usage_cluster_name = String::new(); let mut max_usage_overall = 0f64; let mut op_to_count = HashMap::new(); - + for (id, name, cluster) in nodes.get_all_clusters() { println!("Analyzing cluster {:?}: {}", id, name); // Iterate through nodes' usages and keep the max usage one let mut max_usage = None; for (idx, _) in cluster.members().iter().enumerate() { - let usage = - get_usage(usage_out.get_mut(&(id.clone(), name.to_string(), idx)).unwrap()).await; + let usage = get_usage( + &mut cluster_metrics + .get_mut(&(id.clone(), name.to_string(), idx)) + .unwrap() + .cpu, + ) + .await; println!("Node {} usage: {}", idx, usage); if let Some((prev_usage, _)) = max_usage { if usage > prev_usage { @@ -244,14 +251,15 @@ pub async fn analyze_cluster_results( if let Some((usage, idx)) = max_usage { // Modify IR with perf & cardinality numbers - let node_cardinality = cardinality_out + let metrics = cluster_metrics .get_mut(&(id.clone(), name.to_string(), idx)) .unwrap(); + println!("{} measurements", idx); let unidentified_perf = analyze_process_results( cluster.members().get(idx).unwrap(), ir, &mut op_to_count, - node_cardinality, + metrics, ) .await; diff --git a/hydro_optimize_examples/examples/benchmark_paxos.rs b/hydro_optimize_examples/examples/benchmark_paxos.rs index 162d072..d06d26a 100644 --- a/hydro_optimize_examples/examples/benchmark_paxos.rs +++ b/hydro_optimize_examples/examples/benchmark_paxos.rs @@ -1,15 +1,11 @@ -use std::cell::RefCell; use clap::{ArgAction, Parser}; use hydro_deploy::Deployment; -use hydro_lang::location::Location; use hydro_optimize::deploy::{HostType, ReusableHosts}; use hydro_optimize::deploy_and_analyze::{ Optimizations, ReusableClusters, ReusableProcesses, deploy_and_optimize, }; -use hydro_test::cluster::kv_replica::Replica; -use hydro_test::cluster::paxos::{Acceptor, CorePaxos, PaxosConfig, Proposer}; -use hydro_test::cluster::paxos_bench::{Aggregator, Client}; +use hydro_test::cluster::paxos::{CorePaxos, PaxosConfig}; #[derive(Parser, Debug)] #[command(author, version, about, long_about = None, group( @@ -56,7 +52,6 @@ async fn main() { let num_clients_per_node = vec![1, 50, 100]; let run_seconds = 30; - let mut iteration = 0; let max_num_clients_per_node = num_clients_per_node.iter().max().unwrap(); for (i, num_clients) in num_clients.iter().enumerate() { // For the 1st client, test a variable number of virtual clients. For the rest, use the max number. @@ -113,8 +108,6 @@ async fn main() { Some(run_seconds), ) .await; - - iteration += 1; } } } diff --git a/hydro_optimize_examples/examples/network_calibrator.rs b/hydro_optimize_examples/examples/network_calibrator.rs index 98eb6ce..17cee8e 100644 --- a/hydro_optimize_examples/examples/network_calibrator.rs +++ b/hydro_optimize_examples/examples/network_calibrator.rs @@ -1,13 +1,12 @@ use clap::{ArgAction, Parser}; use hydro_deploy::Deployment; -use hydro_lang::location::Location; use hydro_lang::prelude::FlowBuilder; use hydro_lang::viz::config::GraphConfig; use hydro_optimize::deploy::{HostType, ReusableHosts}; use hydro_optimize::deploy_and_analyze::{ Optimizations, ReusableClusters, ReusableProcesses, deploy_and_optimize, }; -use hydro_optimize_examples::network_calibrator::{Aggregator, Client, Server, network_calibrator}; +use hydro_optimize_examples::network_calibrator::{Aggregator, Client, network_calibrator}; #[derive(Parser, Debug)] #[command(author, version, about, long_about = None, group( diff --git a/hydro_optimize_examples/examples/partition_two_pc.rs b/hydro_optimize_examples/examples/partition_two_pc.rs index e491805..1a74bc7 100644 --- a/hydro_optimize_examples/examples/partition_two_pc.rs +++ b/hydro_optimize_examples/examples/partition_two_pc.rs @@ -1,14 +1,11 @@ -use std::cell::RefCell; use clap::{ArgAction, Parser}; use hydro_deploy::Deployment; -use hydro_lang::location::Location; use hydro_lang::viz::config::GraphConfig; use hydro_optimize::deploy::{HostType, ReusableHosts}; use hydro_optimize::deploy_and_analyze::{ Optimizations, ReusableClusters, ReusableProcesses, deploy_and_optimize, }; -use hydro_test::cluster::two_pc::{Coordinator, Participant}; use hydro_test::cluster::two_pc_bench::{Aggregator, Client}; #[derive(Parser, Debug)] From c3efe78f5ce1a0acd58de088729c04f038655316 Mon Sep 17 00:00:00 2001 From: David Chu Date: Thu, 29 Jan 2026 22:46:17 +0000 Subject: [PATCH 23/35] Network sidecar works --- hydro_optimize/src/deploy_and_analyze.rs | 26 ++++++++++++++++-------- 1 file changed, 18 insertions(+), 8 deletions(-) diff --git a/hydro_optimize/src/deploy_and_analyze.rs b/hydro_optimize/src/deploy_and_analyze.rs index 46df156..16b9f61 100644 --- a/hydro_optimize/src/deploy_and_analyze.rs +++ b/hydro_optimize/src/deploy_and_analyze.rs @@ -131,6 +131,7 @@ async fn track_cluster_metrics( struct ScriptSidecar { script: String, + prefix: String, } impl Sidecar for ScriptSidecar { @@ -143,21 +144,29 @@ impl Sidecar for ScriptSidecar { _dfir_ident: &syn::Ident, ) -> syn::Expr { let script = &self.script; + let prefix = &self.prefix; let location_key_str = format!("{:?}", location_key); syn::parse_quote! { async { - let output = tokio::process::Command::new("sh") + use tokio::process::Command; + use tokio::io::{BufReader, AsyncBufReadExt}; + use std::process::Stdio; + + let mut child = Command::new("sh") .arg("-c") .arg(#script) - .output() - .await - .expect(&format!("Failed to run sidecar script: {}", #script)); - - let stdout = String::from_utf8_lossy(&output.stdout); - for line in stdout.lines() { - println!("{}: {}", #location_key_str, line); + .stdout(Stdio::piped()) + .spawn() + .expect("Failed to spawn sidecar"); + + let stdout = child.stdout.take().expect("Failed to open sidecar stdout"); + let mut reader = BufReader::new(stdout).lines(); + while let Some(line) = reader.next_line().await.expect("Failed to read line from sidecar") { + println!("{}{}: {}", #prefix, #location_key_str, line); } + + child.wait().await.expect("Failed to wait for sidecar"); } } } @@ -286,6 +295,7 @@ pub async fn deploy_and_optimize<'a>( } let network_sidecar = ScriptSidecar { script: "sar -n DEV 1".to_string(), + prefix: NETWORK_USAGE_PREFIX.to_string(), }; let nodes = deployable .with_sidecar_all(&network_sidecar) // Measure network usage From 02e35b43e9783b7f589c5f22b8a9e52a8ea55f00 Mon Sep 17 00:00:00 2001 From: David Chu Date: Thu, 29 Jan 2026 15:17:15 -0800 Subject: [PATCH 24/35] Calculate p50, p99, p999 network usage --- hydro_optimize/src/deploy_and_analyze.rs | 3 +- hydro_optimize/src/parse_results.rs | 85 ++++++++++++++++++++++-- hydro_optimize/src/tests/mod.rs | 14 ++-- 3 files changed, 89 insertions(+), 13 deletions(-) diff --git a/hydro_optimize/src/deploy_and_analyze.rs b/hydro_optimize/src/deploy_and_analyze.rs index 16b9f61..cb07fc9 100644 --- a/hydro_optimize/src/deploy_and_analyze.rs +++ b/hydro_optimize/src/deploy_and_analyze.rs @@ -20,6 +20,7 @@ use crate::deploy::ReusableHosts; use crate::parse_results::{RunMetadata, analyze_cluster_results, analyze_send_recv_overheads}; use crate::repair::{cycle_source_to_sink_input, inject_id, remove_counter}; +pub(crate) const METRIC_INTERVAL_SECS: usize = 1; const COUNTER_PREFIX: &str = "_optimize_counter"; pub(crate) const CPU_USAGE_PREFIX: &str = "HYDRO_OPTIMIZE_CPU:"; pub(crate) const NETWORK_USAGE_PREFIX: &str = "HYDRO_OPTIMIZE_NET:"; @@ -264,7 +265,7 @@ pub async fn deploy_and_optimize<'a>( optimizations: Optimizations, num_seconds: Option, ) { - let counter_output_duration = syn::parse_quote!(std::time::Duration::from_secs(1)); + let counter_output_duration = syn::parse_quote!(std::time::Duration::from_secs(#METRIC_INTERVAL_SECS)); if optimizations.iterations > 1 && num_seconds.is_none() { panic!("Cannot specify multiple iterations without bounding run time"); diff --git a/hydro_optimize/src/parse_results.rs b/hydro_optimize/src/parse_results.rs index 0928fa6..f47857b 100644 --- a/hydro_optimize/src/parse_results.rs +++ b/hydro_optimize/src/parse_results.rs @@ -10,12 +10,82 @@ use tokio::sync::mpsc::UnboundedReceiver; use crate::deploy_and_analyze::Metrics; +/// Network usage statistics with percentile values +#[derive(Debug, Default, Clone)] +pub struct NetworkStats { + pub rx_packets_per_sec: PercentileStats, + pub tx_packets_per_sec: PercentileStats, + pub rx_bytes_per_sec: PercentileStats, + pub tx_bytes_per_sec: PercentileStats, +} + +#[derive(Debug, Default, Clone, Copy)] +pub struct PercentileStats { + pub p50: f64, + pub p99: f64, + pub p999: f64, +} + +impl PercentileStats { + fn from_samples(samples: &mut [f64]) -> Self { + if samples.is_empty() { + return Self::default(); + } + samples.sort_by(|a, b| a.partial_cmp(b).unwrap()); + let len = samples.len(); + Self { + p50: samples[len * 50 / 100], + p99: samples[len * 99 / 100], + p999: samples[len.saturating_sub(1).min(len * 999 / 1000)], + } + } +} + +/// Parses `sar -n DEV` output lines and computes p50, p99, p999 for network metrics. +/// Only considers eth0 interface data. +pub fn parse_network_usage(lines: Vec) -> NetworkStats { + let mut rx_pkt_samples = Vec::new(); + let mut tx_pkt_samples = Vec::new(); + let mut rx_kb_samples = Vec::new(); + let mut tx_kb_samples = Vec::new(); + + // sar output format: TIME IFACE rxpck/s txpck/s rxkB/s txkB/s ... + // We look for lines containing "eth0" with numeric data + let eth0_regex = + Regex::new(r"eth0\s+(\d+\.?\d*)\s+(\d+\.?\d*)\s+(\d+\.?\d*)\s+(\d+\.?\d*)").unwrap(); + + for line in &lines { + if let Some(caps) = eth0_regex.captures(line) { + if let (Ok(rx_pkt), Ok(tx_pkt), Ok(rx_kb), Ok(tx_kb)) = ( + caps[1].parse::(), + caps[2].parse::(), + caps[3].parse::(), + caps[4].parse::(), + ) { + rx_pkt_samples.push(rx_pkt); + tx_pkt_samples.push(tx_pkt); + // Convert kB/s to bytes/s + rx_kb_samples.push(rx_kb * 1024.0); + tx_kb_samples.push(tx_kb * 1024.0); + } + } + } + + NetworkStats { + rx_packets_per_sec: PercentileStats::from_samples(&mut rx_pkt_samples), + tx_packets_per_sec: PercentileStats::from_samples(&mut tx_pkt_samples), + rx_bytes_per_sec: PercentileStats::from_samples(&mut rx_kb_samples), + tx_bytes_per_sec: PercentileStats::from_samples(&mut tx_kb_samples), + } +} + #[derive(Default)] pub struct RunMetadata { pub send_overhead: HashMap, pub recv_overhead: HashMap, pub unaccounted_perf: HashMap, // % of perf samples not mapped to any operator pub total_usage: HashMap, // 100% CPU = 1.0 + pub network_stats: HashMap, } pub fn parse_cpu_usage(measurement: String) -> f64 { @@ -194,7 +264,7 @@ pub async fn analyze_process_results( ir: &mut [HydroRoot], op_to_count: &mut HashMap, metrics: &mut Metrics, -) -> f64 { +) -> (f64, NetworkStats) { let underlying = process.underlying(); let perf_results = underlying.tracing_results().unwrap(); @@ -206,11 +276,15 @@ pub async fn analyze_process_results( let (op_id, count) = parse_counter_usage(measurement.clone()); op_to_count.insert(op_id, count); } + + // Collect and parse network usage data + let mut network_lines = Vec::new(); while let Some(network_usage) = metrics.network.recv().await { - println!("Network: {}", network_usage); + network_lines.push(network_usage); } + let network_stats = parse_network_usage(network_lines); - unidentified_usage + (unidentified_usage, network_stats) } pub async fn analyze_cluster_results( @@ -254,8 +328,7 @@ pub async fn analyze_cluster_results( let metrics = cluster_metrics .get_mut(&(id.clone(), name.to_string(), idx)) .unwrap(); - println!("{} measurements", idx); - let unidentified_perf = analyze_process_results( + let (unidentified_perf, network_stats) = analyze_process_results( cluster.members().get(idx).unwrap(), ir, &mut op_to_count, @@ -267,6 +340,8 @@ pub async fn analyze_cluster_results( run_metadata .unaccounted_perf .insert(id.clone(), unidentified_perf); + run_metadata.network_stats.insert(id.clone(), network_stats.clone()); + println!("Network stats for {}: {:?}", idx, network_stats); // Update cluster with max usage if max_usage_overall < usage && !exclude.contains(&name.to_string()) { diff --git a/hydro_optimize/src/tests/mod.rs b/hydro_optimize/src/tests/mod.rs index fb335db..422f852 100644 --- a/hydro_optimize/src/tests/mod.rs +++ b/hydro_optimize/src/tests/mod.rs @@ -1,4 +1,3 @@ -use std::cell::RefCell; use std::collections::HashMap; use hydro_build_utils::insta; @@ -6,7 +5,7 @@ use hydro_lang::deploy::HydroDeploy; use hydro_lang::location::Location; use hydro_lang::prelude::*; -use crate::decoupler; +use crate::decoupler::{self, DecoupleDecision}; use crate::partitioner::Partitioner; mod two_pc; @@ -19,15 +18,16 @@ fn decoupled_compute_pi_ir() { let (cluster, _) = hydro_test::cluster::compute_pi::compute_pi(&mut builder, 8192); let decoupled_cluster = builder.cluster::(); let decoupler = decoupler::Decoupler { - output_to_decoupled_machine_after: vec![4], - output_to_original_machine_after: vec![], - place_on_decoupled_machine: vec![], + decision: DecoupleDecision { + output_to_decoupled_machine_after: vec![4], + output_to_original_machine_after: vec![], + place_on_decoupled_machine: vec![], + }, decoupled_location: decoupled_cluster.id().clone(), orig_location: cluster.id().clone(), }; - let multi_run_metadata = RefCell::new(vec![]); let mut built = builder - .optimize_with(|roots| decoupler::decouple(roots, &decoupler, &multi_run_metadata, 0)) + .optimize_with(|roots| decoupler::decouple(roots, &decoupler)) .into_deploy::(); insta::assert_debug_snapshot!(built.ir()); From bcbbcd28541b4c8a26b61eb1c70d9eda3966c6af Mon Sep 17 00:00:00 2001 From: David Chu Date: Thu, 29 Jan 2026 16:17:18 -0800 Subject: [PATCH 25/35] Prepping for throughput/latency parsing --- Cargo.lock | 22 +++---- hydro_optimize/src/deploy_and_analyze.rs | 24 +++++--- hydro_optimize/src/parse_results.rs | 61 +++++++++++-------- .../examples/benchmark_paxos.rs | 2 +- 4 files changed, 62 insertions(+), 47 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index e6da0be..7f71fd5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -895,7 +895,7 @@ dependencies = [ [[package]] name = "copy_span" version = "0.1.0" -source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" +source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" dependencies = [ "proc-macro2", "syn", @@ -1114,7 +1114,7 @@ dependencies = [ [[package]] name = "dfir_lang" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" +source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" dependencies = [ "auto_impl", "documented", @@ -1780,7 +1780,7 @@ checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" [[package]] name = "hydro_build_utils" version = "0.0.1" -source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" +source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" dependencies = [ "insta", "rustc_version", @@ -1789,7 +1789,7 @@ dependencies = [ [[package]] name = "hydro_deploy" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" +source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" dependencies = [ "anyhow", "append-only-vec", @@ -1825,7 +1825,7 @@ dependencies = [ [[package]] name = "hydro_deploy_integration" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" +source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" dependencies = [ "async-recursion", "async-trait", @@ -1843,7 +1843,7 @@ dependencies = [ [[package]] name = "hydro_lang" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" +source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" dependencies = [ "auto_impl", "backtrace", @@ -1934,7 +1934,7 @@ dependencies = [ [[package]] name = "hydro_std" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" +source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" dependencies = [ "hdrhistogram", "hydro_lang", @@ -1946,7 +1946,7 @@ dependencies = [ [[package]] name = "hydro_test" version = "0.0.0" -source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" +source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" dependencies = [ "bytes", "colored", @@ -2156,7 +2156,7 @@ dependencies = [ [[package]] name = "include_mdtests" version = "0.0.0" -source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" +source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" dependencies = [ "glob", "proc-macro2", @@ -4005,7 +4005,7 @@ checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa" [[package]] name = "sinktools" version = "0.0.1" -source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" +source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" dependencies = [ "futures-util", "pin-project-lite", @@ -4789,7 +4789,7 @@ checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" [[package]] name = "variadics" version = "0.0.10" -source = "git+https://github.com/hydro-project/hydro.git#0fafcf4bcf932a90f3b489a254246ce2d3e75b9f" +source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" dependencies = [ "hashbrown 0.14.5", "hydro_build_utils", diff --git a/hydro_optimize/src/deploy_and_analyze.rs b/hydro_optimize/src/deploy_and_analyze.rs index cb07fc9..4dfc865 100644 --- a/hydro_optimize/src/deploy_and_analyze.rs +++ b/hydro_optimize/src/deploy_and_analyze.rs @@ -20,7 +20,7 @@ use crate::deploy::ReusableHosts; use crate::parse_results::{RunMetadata, analyze_cluster_results, analyze_send_recv_overheads}; use crate::repair::{cycle_source_to_sink_input, inject_id, remove_counter}; -pub(crate) const METRIC_INTERVAL_SECS: usize = 1; +pub(crate) const METRIC_INTERVAL_SECS: u64 = 1; const COUNTER_PREFIX: &str = "_optimize_counter"; pub(crate) const CPU_USAGE_PREFIX: &str = "HYDRO_OPTIMIZE_CPU:"; pub(crate) const NETWORK_USAGE_PREFIX: &str = "HYDRO_OPTIMIZE_NET:"; @@ -99,14 +99,14 @@ fn insert_counter(ir: &mut [HydroRoot], duration: &syn::Expr) { ); } -pub struct Metrics { +pub struct MetricLogs { pub cpu: UnboundedReceiver, pub network: UnboundedReceiver, pub counters: UnboundedReceiver, } -async fn track_process_metrics(process: &impl DeployCrateWrapper) -> Metrics { - Metrics { +async fn track_process_metrics(process: &impl DeployCrateWrapper) -> MetricLogs { + MetricLogs { cpu: process.stdout_filter(CPU_USAGE_PREFIX), network: process.stdout_filter(NETWORK_USAGE_PREFIX), counters: process.stdout_filter(COUNTER_PREFIX), @@ -115,7 +115,7 @@ async fn track_process_metrics(process: &impl DeployCrateWrapper) -> Metrics { async fn track_cluster_metrics( nodes: &DeployResult<'_, HydroDeploy>, -) -> HashMap<(LocationId, String, usize), Metrics> { +) -> HashMap<(LocationId, String, usize), MetricLogs> { let mut cluster_to_metrics = HashMap::new(); for (id, name, cluster) in nodes.get_all_clusters() { for (idx, node) in cluster.members().iter().enumerate() { @@ -264,13 +264,15 @@ pub async fn deploy_and_optimize<'a>( processes: ReusableProcesses, optimizations: Optimizations, num_seconds: Option, -) { - let counter_output_duration = syn::parse_quote!(std::time::Duration::from_secs(#METRIC_INTERVAL_SECS)); - +) -> RunMetadata { if optimizations.iterations > 1 && num_seconds.is_none() { panic!("Cannot specify multiple iterations without bounding run time"); } + let counter_output_duration = + syn::parse_quote!(std::time::Duration::from_secs(#METRIC_INTERVAL_SECS)); + let mut run_metadata = RunMetadata::default(); + for iteration in 0..optimizations.iterations { // Rewrite with counter tracking let mut post_rewrite_builder = FlowBuilder::from_built(&builder); @@ -325,8 +327,8 @@ pub async fn deploy_and_optimize<'a>( .await .unwrap(); - // Add metadata for this run - let mut run_metadata = RunMetadata::default(); + // Add metadata for this run, clearing the metadata from the previous run + run_metadata = RunMetadata::default(); let (bottleneck, bottleneck_name, bottleneck_num_nodes) = analyze_cluster_results( &nodes, &mut ir, @@ -382,4 +384,6 @@ pub async fn deploy_and_optimize<'a>( builder = post_rewrite_builder.finalize(); } + + run_metadata } diff --git a/hydro_optimize/src/parse_results.rs b/hydro_optimize/src/parse_results.rs index f47857b..deed53d 100644 --- a/hydro_optimize/src/parse_results.rs +++ b/hydro_optimize/src/parse_results.rs @@ -8,15 +8,26 @@ use hydro_lang::location::dynamic::LocationId; use regex::Regex; use tokio::sync::mpsc::UnboundedReceiver; -use crate::deploy_and_analyze::Metrics; +use crate::deploy_and_analyze::MetricLogs; -/// Network usage statistics with percentile values -#[derive(Debug, Default, Clone)] -pub struct NetworkStats { - pub rx_packets_per_sec: PercentileStats, - pub tx_packets_per_sec: PercentileStats, - pub rx_bytes_per_sec: PercentileStats, - pub tx_bytes_per_sec: PercentileStats, +#[derive(Default)] +pub struct RunMetadata { + pub throughput: (f64, f64, f64), // mean - 2 std, mean, mean + 2 std + pub latencies: (f64, f64, f64, u64), // p50, p99, p999, count + pub send_overhead: HashMap, + pub recv_overhead: HashMap, + pub unaccounted_perf: HashMap, // % of perf samples not mapped to any operator + pub total_usage: HashMap, // 100% CPU = 1.0 + pub network_stats: HashMap, +} + +pub fn parse_cpu_usage(measurement: String) -> f64 { + let regex = Regex::new(r"Total (\d+\.\d+)%").unwrap(); + regex + .captures_iter(&measurement) + .last() + .map(|cap| cap[1].parse::().unwrap()) + .unwrap_or(0f64) } #[derive(Debug, Default, Clone, Copy)] @@ -26,6 +37,14 @@ pub struct PercentileStats { pub p999: f64, } +#[derive(Debug, Default, Clone)] +pub struct NetworkStats { + pub rx_packets_per_sec: PercentileStats, + pub tx_packets_per_sec: PercentileStats, + pub rx_bytes_per_sec: PercentileStats, + pub tx_bytes_per_sec: PercentileStats, +} + impl PercentileStats { fn from_samples(samples: &mut [f64]) -> Self { if samples.is_empty() { @@ -79,22 +98,12 @@ pub fn parse_network_usage(lines: Vec) -> NetworkStats { } } -#[derive(Default)] -pub struct RunMetadata { - pub send_overhead: HashMap, - pub recv_overhead: HashMap, - pub unaccounted_perf: HashMap, // % of perf samples not mapped to any operator - pub total_usage: HashMap, // 100% CPU = 1.0 - pub network_stats: HashMap, +pub fn parse_throughput(lines: Vec) -> (f64, f64, f64) { + todo!() } -pub fn parse_cpu_usage(measurement: String) -> f64 { - let regex = Regex::new(r"Total (\d+\.\d+)%").unwrap(); - regex - .captures_iter(&measurement) - .last() - .map(|cap| cap[1].parse::().unwrap()) - .unwrap_or(0f64) +pub fn parse_latency(lines: Vec) -> (f64, f64, f64, u64) { + todo!() } /// Returns a map from (operator ID, is network receiver) to percentage of total samples, and the percentage of samples that are unaccounted @@ -263,7 +272,7 @@ pub async fn analyze_process_results( process: &impl DeployCrateWrapper, ir: &mut [HydroRoot], op_to_count: &mut HashMap, - metrics: &mut Metrics, + metrics: &mut MetricLogs, ) -> (f64, NetworkStats) { let underlying = process.underlying(); let perf_results = underlying.tracing_results().unwrap(); @@ -290,7 +299,7 @@ pub async fn analyze_process_results( pub async fn analyze_cluster_results( nodes: &DeployResult<'_, HydroDeploy>, ir: &mut [HydroRoot], - mut cluster_metrics: HashMap<(LocationId, String, usize), Metrics>, + mut cluster_metrics: HashMap<(LocationId, String, usize), MetricLogs>, run_metadata: &mut RunMetadata, exclude: &Vec, ) -> (LocationId, String, usize) { @@ -340,7 +349,9 @@ pub async fn analyze_cluster_results( run_metadata .unaccounted_perf .insert(id.clone(), unidentified_perf); - run_metadata.network_stats.insert(id.clone(), network_stats.clone()); + run_metadata + .network_stats + .insert(id.clone(), network_stats.clone()); println!("Network stats for {}: {:?}", idx, network_stats); // Update cluster with max usage diff --git a/hydro_optimize_examples/examples/benchmark_paxos.rs b/hydro_optimize_examples/examples/benchmark_paxos.rs index d06d26a..ed818f7 100644 --- a/hydro_optimize_examples/examples/benchmark_paxos.rs +++ b/hydro_optimize_examples/examples/benchmark_paxos.rs @@ -94,7 +94,7 @@ async fn main() { &replicas, ); - deploy_and_optimize( + let run_metadata = deploy_and_optimize( &mut reusable_hosts, &mut deployment, builder.finalize(), From 832d583a9aa38bda6b98821a32a50e3082b0052f Mon Sep 17 00:00:00 2001 From: David Chu Date: Mon, 2 Feb 2026 15:37:56 -0800 Subject: [PATCH 26/35] (based on #2522) RunMetadata returns throughput and latency --- hydro_optimize/src/deploy_and_analyze.rs | 6 + hydro_optimize/src/parse_results.rs | 131 ++++++++++++++---- .../examples/benchmark_paxos.rs | 4 +- .../examples/partition_two_pc.rs | 3 + .../examples/perf_paxos.rs | 3 + 5 files changed, 121 insertions(+), 26 deletions(-) diff --git a/hydro_optimize/src/deploy_and_analyze.rs b/hydro_optimize/src/deploy_and_analyze.rs index 4dfc865..a12f313 100644 --- a/hydro_optimize/src/deploy_and_analyze.rs +++ b/hydro_optimize/src/deploy_and_analyze.rs @@ -24,6 +24,8 @@ pub(crate) const METRIC_INTERVAL_SECS: u64 = 1; const COUNTER_PREFIX: &str = "_optimize_counter"; pub(crate) const CPU_USAGE_PREFIX: &str = "HYDRO_OPTIMIZE_CPU:"; pub(crate) const NETWORK_USAGE_PREFIX: &str = "HYDRO_OPTIMIZE_NET:"; +pub(crate) const LATENCY_PREFIX: &str = "HYDRO_OPTIMIZE_LAT:"; +pub(crate) const THROUGHPUT_PREFIX: &str = "HYDRO_OPTIMIZE_THR:"; // Note: Ensure edits to the match arms are consistent with inject_count_node fn insert_counter_node(node: &mut HydroNode, next_stmt_id: &mut usize, duration: syn::Expr) { @@ -100,6 +102,8 @@ fn insert_counter(ir: &mut [HydroRoot], duration: &syn::Expr) { } pub struct MetricLogs { + pub throughputs: UnboundedReceiver, + pub latencies: UnboundedReceiver, pub cpu: UnboundedReceiver, pub network: UnboundedReceiver, pub counters: UnboundedReceiver, @@ -107,6 +111,8 @@ pub struct MetricLogs { async fn track_process_metrics(process: &impl DeployCrateWrapper) -> MetricLogs { MetricLogs { + throughputs: process.stdout_filter(THROUGHPUT_PREFIX), + latencies: process.stdout_filter(LATENCY_PREFIX), cpu: process.stdout_filter(CPU_USAGE_PREFIX), network: process.stdout_filter(NETWORK_USAGE_PREFIX), counters: process.stdout_filter(COUNTER_PREFIX), diff --git a/hydro_optimize/src/parse_results.rs b/hydro_optimize/src/parse_results.rs index deed53d..c0bc4cc 100644 --- a/hydro_optimize/src/parse_results.rs +++ b/hydro_optimize/src/parse_results.rs @@ -1,5 +1,6 @@ use std::collections::HashMap; +use crate::deploy_and_analyze::{LATENCY_PREFIX, THROUGHPUT_PREFIX}; use hydro_lang::compile::deploy::DeployResult; use hydro_lang::compile::ir::{HydroNode, HydroRoot, traverse_dfir}; use hydro_lang::deploy::HydroDeploy; @@ -98,12 +99,88 @@ pub fn parse_network_usage(lines: Vec) -> NetworkStats { } } +pub fn print_parseable_bench_results<'a, Aggregator>( + aggregate_results: AggregateBenchResult<'a, Aggregator>, + interval_millis: u64, +) { + aggregate_results + .throughput + .filter_map(q!(move |(throughputs, num_client_machines)| { + if let Some((lower, upper)) = throughputs.confidence_interval_99() { + Some(( + lower * num_client_machines as f64, + throughputs.sample_mean() * num_client_machines as f64, + upper * num_client_machines as f64, + )) + } else { + None + } + })) + .for_each(q!(|(lower, mean, upper)| { + println!( + "{} {:.2} - {:.2} - {:.2} requests/s", + THROUGHPUT_PREFIX, lower, mean, upper, + ); + })); + aggregate_results + .latency + .map(q!(move |latencies| ( + Duration::from_nanos(latencies.value_at_quantile(0.5)).as_micros() as f64 + / interval_millis as f64, + Duration::from_nanos(latencies.value_at_quantile(0.99)).as_micros() as f64 + / interval_millis as f64, + Duration::from_nanos(latencies.value_at_quantile(0.999)).as_micros() as f64 + / interval_millis as f64, + latencies.len(), + ))) + .for_each(q!(move |(p50, p99, p999, num_samples)| { + println!( + "{} p50: {:.3} | p99 {:.3} | p999 {:.3} ms ({:} samples)", + LATENCY_PREFIX, p50, p99, p999, num_samples + ); + })); +} + +/// Parses throughput output from `print_parseable_bench_results`. +/// Format: "HYDRO_OPTIMIZE_THR: {lower:.2} - {mean:.2} - {upper:.2} requests/s" +/// Returns the last (lower, mean, upper) tuple found. pub fn parse_throughput(lines: Vec) -> (f64, f64, f64) { - todo!() + let regex = + Regex::new(r"(\d+\.?\d*)\s*-\s*(\d+\.?\d*)\s*-\s*(\d+\.?\d*)\s*requests/s").unwrap(); + lines + .iter() + .filter_map(|line| { + regex.captures(line).map(|cap| { + ( + cap[1].parse::().unwrap(), + cap[2].parse::().unwrap(), + cap[3].parse::().unwrap(), + ) + }) + }) + .last() + .unwrap() } +/// Parses latency output from `print_parseable_bench_results`. +/// Format: "HYDRO_OPTIMIZE_LAT: p50: {p50:.3} | p99 {p99:.3} | p999 {p999:.3} ms ({num_samples} samples)" +/// Returns the last (p50, p99, p999, num_samples) tuple found. pub fn parse_latency(lines: Vec) -> (f64, f64, f64, u64) { - todo!() + let regex = Regex::new(r"p50:\s*(\d+\.?\d*)\s*\|\s*p99\s+(\d+\.?\d*)\s*\|\s*p999\s+(\d+\.?\d*)\s*ms\s*\((\d+)\s*samples\)").unwrap(); + lines + .iter() + .filter_map(|line| { + regex.captures(line).map(|cap| { + ( + cap[1].parse::().unwrap(), + cap[2].parse::().unwrap(), + cap[3].parse::().unwrap(), + cap[4].parse::().unwrap(), + ) + }) + }) + .last() + .unwrap() } /// Returns a map from (operator ID, is network receiver) to percentage of total samples, and the percentage of samples that are unaccounted @@ -187,12 +264,14 @@ pub fn inject_perf(ir: &mut [HydroRoot], folded_data: Vec) -> f64 { } /// Returns (op_id, count) -pub fn parse_counter_usage(measurement: String) -> (usize, usize) { - let regex = Regex::new(r"\((\d+)\): (\d+)").unwrap(); - let matches = regex.captures_iter(&measurement).last().unwrap(); - let op_id = matches[1].parse::().unwrap(); - let count = matches[2].parse::().unwrap(); - (op_id, count) +pub fn parse_counter_usage(lines: Vec, op_to_count: &mut HashMap) { + for measurement in lines { + let regex = Regex::new(r"\((\d+)\): (\d+)").unwrap(); + let matches = regex.captures_iter(&measurement).last().unwrap(); + let op_id = matches[1].parse::().unwrap(); + let count = matches[2].parse::().unwrap(); + op_to_count.insert(op_id, count); + } } // Note: Ensure edits to the match arms are consistent with insert_counter_node @@ -268,32 +347,31 @@ pub fn inject_count(ir: &mut [HydroRoot], op_to_count: &HashMap) { ); } +/// Drains all messages from a receiver into a Vec. +async fn drain_receiver(receiver: &mut UnboundedReceiver) -> Vec { + let mut lines = Vec::new(); + while let Some(line) = receiver.recv().await { + lines.push(line); + } + lines +} + pub async fn analyze_process_results( process: &impl DeployCrateWrapper, ir: &mut [HydroRoot], op_to_count: &mut HashMap, metrics: &mut MetricLogs, -) -> (f64, NetworkStats) { +) -> (u64, NetworkStats) { let underlying = process.underlying(); let perf_results = underlying.tracing_results().unwrap(); // Inject perf usages into metadata - let unidentified_usage = inject_perf(ir, perf_results.folded_data.clone()); + let unidentified_perf = inject_perf(ir, perf_results.folded_data.clone()); - // Get cardinality data. Allow later values to overwrite earlier ones - while let Some(measurement) = metrics.counters.recv().await { - let (op_id, count) = parse_counter_usage(measurement.clone()); - op_to_count.insert(op_id, count); - } - - // Collect and parse network usage data - let mut network_lines = Vec::new(); - while let Some(network_usage) = metrics.network.recv().await { - network_lines.push(network_usage); - } - let network_stats = parse_network_usage(network_lines); - - (unidentified_usage, network_stats) + // Parse all metric streams + parse_counter_usage(drain_receiver(&mut metrics.counters).await, op_to_count); + let network_stats = parse_network_usage(drain_receiver(&mut metrics.network).await); + (unidentified_perf, network_stats) } pub async fn analyze_cluster_results( @@ -348,7 +426,7 @@ pub async fn analyze_cluster_results( run_metadata.total_usage.insert(id.clone(), usage); run_metadata .unaccounted_perf - .insert(id.clone(), unidentified_perf); + .insert(id.clone(), unidentified_perf as f64); run_metadata .network_stats .insert(id.clone(), network_stats.clone()); @@ -365,6 +443,9 @@ pub async fn analyze_cluster_results( } } + run_metadata.throughput = parse_throughput(drain_receiver(&mut metrics.throughputs).await); + run_metadata.latencies = parse_latency(drain_receiver(&mut metrics.latencies).await); + inject_count(ir, &op_to_count); ( diff --git a/hydro_optimize_examples/examples/benchmark_paxos.rs b/hydro_optimize_examples/examples/benchmark_paxos.rs index ed818f7..69e0a31 100644 --- a/hydro_optimize_examples/examples/benchmark_paxos.rs +++ b/hydro_optimize_examples/examples/benchmark_paxos.rs @@ -1,4 +1,3 @@ - use clap::{ArgAction, Parser}; use hydro_deploy::Deployment; use hydro_optimize::deploy::{HostType, ReusableHosts}; @@ -46,6 +45,7 @@ async fn main() { let i_am_leader_send_timeout = 5; // Sec let i_am_leader_check_timeout = 10; // Sec let i_am_leader_check_timeout_delay_multiplier = 15; + let print_result_frequency = 1000; // Millis // Benchmark parameters let num_clients = [1, 2, 3, 4, 5]; @@ -92,6 +92,8 @@ async fn main() { &clients, &client_aggregator, &replicas, + print_result_frequency, + hydro_std::bench_client::pretty_print_bench_results, ); let run_metadata = deploy_and_optimize( diff --git a/hydro_optimize_examples/examples/partition_two_pc.rs b/hydro_optimize_examples/examples/partition_two_pc.rs index 1a74bc7..07f3f29 100644 --- a/hydro_optimize_examples/examples/partition_two_pc.rs +++ b/hydro_optimize_examples/examples/partition_two_pc.rs @@ -46,6 +46,7 @@ async fn main() { let num_participants = 3; let num_clients = 3; let num_clients_per_node = 100; + let print_result_frequency = 1000; // Millis let coordinator = builder.process(); let participants = builder.cluster(); @@ -59,6 +60,8 @@ async fn main() { num_participants, &clients, &client_aggregator, + print_result_frequency, + hydro_std::bench_client::pretty_print_bench_results, ); deploy_and_optimize( diff --git a/hydro_optimize_examples/examples/perf_paxos.rs b/hydro_optimize_examples/examples/perf_paxos.rs index 4f81a0d..566a9d1 100644 --- a/hydro_optimize_examples/examples/perf_paxos.rs +++ b/hydro_optimize_examples/examples/perf_paxos.rs @@ -48,6 +48,7 @@ async fn main() { let i_am_leader_send_timeout = 5; // Sec let i_am_leader_check_timeout = 10; // Sec let i_am_leader_check_timeout_delay_multiplier = 15; + let print_result_frequency = 1000; // Millis let proposers = builder.cluster(); let acceptors = builder.cluster(); @@ -73,6 +74,8 @@ async fn main() { &clients, &client_aggregator, &replicas, + print_result_frequency, + hydro_std::bench_client::pretty_print_bench_results, ); // Deploy From b42638f5b241db5f1990c47fe2e64aa27ecb1860 Mon Sep 17 00:00:00 2001 From: David Chu Date: Mon, 2 Feb 2026 16:05:51 -0800 Subject: [PATCH 27/35] WIP benchmark paxos auto-finds config before p99 latency spike --- hydro_optimize/src/parse_results.rs | 24 +- .../examples/benchmark_paxos.rs | 230 ++++++++++++------ .../examples/partition_two_pc.rs | 2 +- .../examples/perf_paxos.rs | 2 +- 4 files changed, 180 insertions(+), 78 deletions(-) diff --git a/hydro_optimize/src/parse_results.rs b/hydro_optimize/src/parse_results.rs index c0bc4cc..956be44 100644 --- a/hydro_optimize/src/parse_results.rs +++ b/hydro_optimize/src/parse_results.rs @@ -347,10 +347,11 @@ pub fn inject_count(ir: &mut [HydroRoot], op_to_count: &HashMap) { ); } -/// Drains all messages from a receiver into a Vec. -async fn drain_receiver(receiver: &mut UnboundedReceiver) -> Vec { +/// Drains all currently available messages from a receiver into a Vec. +/// Uses try_recv() to avoid blocking if the channel is empty but not closed. +fn drain_receiver(receiver: &mut UnboundedReceiver) -> Vec { let mut lines = Vec::new(); - while let Some(line) = receiver.recv().await { + while let Ok(line) = receiver.try_recv() { lines.push(line); } lines @@ -369,8 +370,8 @@ pub async fn analyze_process_results( let unidentified_perf = inject_perf(ir, perf_results.folded_data.clone()); // Parse all metric streams - parse_counter_usage(drain_receiver(&mut metrics.counters).await, op_to_count); - let network_stats = parse_network_usage(drain_receiver(&mut metrics.network).await); + parse_counter_usage(drain_receiver(&mut metrics.counters), op_to_count); + let network_stats = parse_network_usage(drain_receiver(&mut metrics.network)); (unidentified_perf, network_stats) } @@ -443,8 +444,17 @@ pub async fn analyze_cluster_results( } } - run_metadata.throughput = parse_throughput(drain_receiver(&mut metrics.throughputs).await); - run_metadata.latencies = parse_latency(drain_receiver(&mut metrics.latencies).await); + // Collect throughput/latency from all processes (aggregator outputs these) + for metrics in cluster_metrics.values_mut() { + // Filter metrics until we find the Aggregator + let throughputs = drain_receiver(&mut metrics.throughputs); + if throughputs.is_empty() { + continue; + } + + run_metadata.throughput = parse_throughput(throughputs); + run_metadata.latencies = parse_latency(drain_receiver(&mut metrics.latencies)); + } inject_count(ir, &op_to_count); diff --git a/hydro_optimize_examples/examples/benchmark_paxos.rs b/hydro_optimize_examples/examples/benchmark_paxos.rs index 69e0a31..cf106f9 100644 --- a/hydro_optimize_examples/examples/benchmark_paxos.rs +++ b/hydro_optimize_examples/examples/benchmark_paxos.rs @@ -4,6 +4,7 @@ use hydro_optimize::deploy::{HostType, ReusableHosts}; use hydro_optimize::deploy_and_analyze::{ Optimizations, ReusableClusters, ReusableProcesses, deploy_and_optimize, }; +use hydro_optimize::parse_results::print_parseable_bench_results; use hydro_test::cluster::paxos::{CorePaxos, PaxosConfig}; #[derive(Parser, Debug)] @@ -25,6 +26,98 @@ struct BenchmarkArgs { aws: bool, } +/// Result of a single benchmark run +struct BenchResult { + virtual_clients: usize, + throughput_mean: f64, + p99_latency: f64, +} + +/// Runs a single Paxos benchmark with the given parameters +async fn run_benchmark( + reusable_hosts: &mut ReusableHosts, + deployment: &mut Deployment, + num_clients: usize, + num_clients_per_node: usize, + run_seconds: usize, +) -> BenchResult { + let f = 1; + let checkpoint_frequency = 1000; + let i_am_leader_send_timeout = 5; + let i_am_leader_check_timeout = 10; + let i_am_leader_check_timeout_delay_multiplier = 15; + let print_result_frequency = 1000; + + println!( + "Running Paxos with {} clients and {} virtual clients per node for {} seconds", + num_clients, num_clients_per_node, run_seconds + ); + + let mut builder = hydro_lang::compile::builder::FlowBuilder::new(); + let proposers = builder.cluster(); + let acceptors = builder.cluster(); + let clients = builder.cluster(); + let client_aggregator = builder.process(); + let replicas = builder.cluster(); + + hydro_test::cluster::paxos_bench::paxos_bench( + num_clients_per_node, + checkpoint_frequency, + f, + f + 1, + CorePaxos { + proposers: proposers.clone(), + acceptors: acceptors.clone(), + paxos_config: PaxosConfig { + f, + i_am_leader_send_timeout, + i_am_leader_check_timeout, + i_am_leader_check_timeout_delay_multiplier, + }, + }, + &clients, + &client_aggregator, + &replicas, + print_result_frequency, + print_parseable_bench_results, + ); + + let run_metadata = deploy_and_optimize( + reusable_hosts, + deployment, + builder.finalize(), + ReusableClusters::new() + .with_cluster(proposers, f + 1) + .with_cluster(acceptors, 2 * f + 1) + .with_cluster(clients, num_clients) + .with_cluster(replicas, f + 1), + ReusableProcesses::new().with_process(client_aggregator), + Optimizations::new(), + Some(run_seconds), + ) + .await; + + let (throughput_lower, throughput_mean, throughput_upper) = run_metadata.throughput; + let (p50_latency, p99_latency, p999_latency, latency_samples) = run_metadata.latencies; + + println!( + "Result: throughput={:.2} req/s (99% CI: {:.2} - {:.2}), latency p50={:.3} ms, p99={:.3} ms, p999={:.3} ms ({} samples)", + throughput_mean, + throughput_lower, + throughput_upper, + p50_latency, + p99_latency, + p999_latency, + latency_samples + ); + + BenchResult { + virtual_clients: num_clients_per_node, + throughput_mean, + p99_latency, + } +} + #[tokio::main] async fn main() { let args = BenchmarkArgs::parse(); @@ -40,76 +133,75 @@ async fn main() { let mut reusable_hosts = ReusableHosts::new(host_type); - let f = 1; - let checkpoint_frequency = 1000; // Num log entries - let i_am_leader_send_timeout = 5; // Sec - let i_am_leader_check_timeout = 10; // Sec - let i_am_leader_check_timeout_delay_multiplier = 15; - let print_result_frequency = 1000; // Millis - - // Benchmark parameters - let num_clients = [1, 2, 3, 4, 5]; - let num_clients_per_node = vec![1, 50, 100]; - let run_seconds = 30; - - let max_num_clients_per_node = num_clients_per_node.iter().max().unwrap(); - for (i, num_clients) in num_clients.iter().enumerate() { - // For the 1st client, test a variable number of virtual clients. For the rest, use the max number. - let virtual_clients = if i == 0 { - &num_clients_per_node + // Fixed parameters + const NUM_CLIENTS: usize = 3; + const RUN_SECONDS: usize = 30; + const LATENCY_SPIKE_THRESHOLD: f64 = 2.0; // p99 latency spike = 2x baseline + + // Binary search for optimal virtual clients + let mut low = 1usize; + let mut high = 200usize; + let mut results: Vec = Vec::new(); + + // First run at low to establish baseline latency + let baseline = run_benchmark( + &mut reusable_hosts, + &mut deployment, + NUM_CLIENTS, + low, + RUN_SECONDS, + ) + .await; + let baseline_p99 = baseline.p99_latency.max(0.001); // Avoid division by zero + results.push(baseline); + + // Binary search to find the point where p99 latency spikes + while high - low > 10 { + let mid = (low + high) / 2; + let result = run_benchmark( + &mut reusable_hosts, + &mut deployment, + NUM_CLIENTS, + mid, + RUN_SECONDS, + ) + .await; + + let latency_ratio = result.p99_latency / baseline_p99; + println!( + "virtual_clients={}, latency_ratio={:.2}x baseline", + mid, latency_ratio + ); + + if latency_ratio > LATENCY_SPIKE_THRESHOLD { + // Latency spiked, search lower + high = mid; } else { - &vec![*max_num_clients_per_node] - }; - - for num_clients_per_node in virtual_clients { - println!( - "Running Paxos with {} clients and {} virtual clients per node for {} seconds", - num_clients, num_clients_per_node, run_seconds - ); - - let mut builder = hydro_lang::compile::builder::FlowBuilder::new(); - let proposers = builder.cluster(); - let acceptors = builder.cluster(); - let clients = builder.cluster(); - let client_aggregator = builder.process(); - let replicas = builder.cluster(); - - hydro_test::cluster::paxos_bench::paxos_bench( - *num_clients_per_node, - checkpoint_frequency, - f, - f + 1, - CorePaxos { - proposers: proposers.clone(), - acceptors: acceptors.clone(), - paxos_config: PaxosConfig { - f, - i_am_leader_send_timeout, - i_am_leader_check_timeout, - i_am_leader_check_timeout_delay_multiplier, - }, - }, - &clients, - &client_aggregator, - &replicas, - print_result_frequency, - hydro_std::bench_client::pretty_print_bench_results, - ); - - let run_metadata = deploy_and_optimize( - &mut reusable_hosts, - &mut deployment, - builder.finalize(), - ReusableClusters::new() - .with_cluster(proposers, f + 1) - .with_cluster(acceptors, 2 * f + 1) - .with_cluster(clients, *num_clients) - .with_cluster(replicas, f + 1), - ReusableProcesses::new().with_process(client_aggregator), - Optimizations::new(), - Some(run_seconds), - ) - .await; + // Latency acceptable, search higher + low = mid; } + results.push(result); + } + + // Final run at the converged value + let optimal = run_benchmark( + &mut reusable_hosts, + &mut deployment, + NUM_CLIENTS, + low, + RUN_SECONDS, + ) + .await; + results.push(optimal); + + // Print summary + println!("\n=== Benchmark Summary ==="); + println!("Optimal virtual clients: {}", low); + println!("\nAll results:"); + for r in &results { + println!( + " virtual_clients={:3}, throughput={:8.2} req/s, p99={:6.3} ms", + r.virtual_clients, r.throughput_mean, r.p99_latency + ); } } diff --git a/hydro_optimize_examples/examples/partition_two_pc.rs b/hydro_optimize_examples/examples/partition_two_pc.rs index 07f3f29..bea9959 100644 --- a/hydro_optimize_examples/examples/partition_two_pc.rs +++ b/hydro_optimize_examples/examples/partition_two_pc.rs @@ -61,7 +61,7 @@ async fn main() { &clients, &client_aggregator, print_result_frequency, - hydro_std::bench_client::pretty_print_bench_results, + print_parseable_bench_results, ); deploy_and_optimize( diff --git a/hydro_optimize_examples/examples/perf_paxos.rs b/hydro_optimize_examples/examples/perf_paxos.rs index 566a9d1..7987790 100644 --- a/hydro_optimize_examples/examples/perf_paxos.rs +++ b/hydro_optimize_examples/examples/perf_paxos.rs @@ -75,7 +75,7 @@ async fn main() { &client_aggregator, &replicas, print_result_frequency, - hydro_std::bench_client::pretty_print_bench_results, + print_parseable_bench_results, ); // Deploy From a6d6861cbec44e475d31a81ca20216e61e7c1931 Mon Sep 17 00:00:00 2001 From: David Chu Date: Mon, 2 Feb 2026 16:30:09 -0800 Subject: [PATCH 28/35] Print fuller stats for each run in benchmark_paxos --- .../examples/benchmark_paxos.rs | 37 +++++++++++++++---- 1 file changed, 29 insertions(+), 8 deletions(-) diff --git a/hydro_optimize_examples/examples/benchmark_paxos.rs b/hydro_optimize_examples/examples/benchmark_paxos.rs index cf106f9..79043e8 100644 --- a/hydro_optimize_examples/examples/benchmark_paxos.rs +++ b/hydro_optimize_examples/examples/benchmark_paxos.rs @@ -101,15 +101,36 @@ async fn run_benchmark( let (p50_latency, p99_latency, p999_latency, latency_samples) = run_metadata.latencies; println!( - "Result: throughput={:.2} req/s (99% CI: {:.2} - {:.2}), latency p50={:.3} ms, p99={:.3} ms, p999={:.3} ms ({} samples)", - throughput_mean, - throughput_lower, - throughput_upper, - p50_latency, - p99_latency, - p999_latency, - latency_samples + "Throughput: {:.2} - {:.2} - {:.2} requests/s", + throughput_lower, throughput_mean, throughput_upper + ); + println!( + "Latency: p50: {:.3} | p99 {:.3} | p999 {:.3} ms ({:} samples)", + p50_latency, p99_latency, p999_latency, latency_samples ); + run_metadata + .total_usage + .iter() + .for_each(|(location, usage)| println!("{:?} CPU: {:.2}%", location, usage * 100.0)); + + // Print network stats summary + for (location, stats) in &run_metadata.network_stats { + let tx_packets = stats.tx_packets_per_sec.p50; + let rx_packets = stats.rx_packets_per_sec.p50; + let tx_bytes = stats.tx_bytes_per_sec.p50; + let rx_bytes = stats.rx_bytes_per_sec.p50; + + println!( + "{:?} Network: msgs sent={:.0}, recv={:.0}, total={:.0} | GB sent={:.3}, recv={:.3}, total={:.3}", + location, + tx_packets, + rx_packets, + tx_packets + rx_packets, + tx_bytes / 1e9, + rx_bytes / 1e9, + (tx_bytes + rx_bytes) / 1e9 + ); + } BenchResult { virtual_clients: num_clients_per_node, From b259578b32a01f59b09b1088d288484730461595 Mon Sep 17 00:00:00 2001 From: David Chu Date: Tue, 3 Feb 2026 15:10:24 -0800 Subject: [PATCH 29/35] Merge latest hydro --- Cargo.lock | 420 +++++++++++++++--- hydro_optimize/Cargo.toml | 3 +- hydro_optimize/src/deploy_and_analyze.rs | 2 +- hydro_optimize/src/parse_results.rs | 18 +- hydro_optimize_examples/Cargo.toml | 4 +- .../examples/perf_paxos.rs | 1 + .../src/network_calibrator.rs | 7 +- .../src/simple_kv_bench.rs | 88 ++-- 8 files changed, 428 insertions(+), 115 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 7f71fd5..934d893 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -457,7 +457,7 @@ dependencies = [ "proc-macro2", "quote", "regex", - "rustc-hash", + "rustc-hash 2.1.1", "shlex", "syn", ] @@ -535,6 +535,121 @@ dependencies = [ "cipher", ] +[[package]] +name = "bolero-afl" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9bf4cbd0bacf9356d3c7e5d9d088480f2076ba3c595c15ee9a6a378cdd7b297" +dependencies = [ + "bolero-engine", + "cc", +] + +[[package]] +name = "bolero-engine" +version = "0.13.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dca199170a7c92c669c1019f9219a316b66bcdcfa4b36cac5a460a4c1a851aba" +dependencies = [ + "anyhow", + "bolero-generator", + "lazy_static", + "pretty-hex", +] + +[[package]] +name = "bolero-engine-hydro" +version = "0.13.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "691790fb2d24fe4984eebd9ef3eb0afc8598a0530471f4d5de499d379e504fc5" +dependencies = [ + "anyhow", + "bolero-generator-hydro", + "lazy_static", + "pretty-hex", + "rand 0.9.2", + "rand_xoshiro", +] + +[[package]] +name = "bolero-generator" +version = "0.13.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "98a5782f2650f80d533f58ec339c6dce4cc5428f9c2755894f98156f52af81f2" +dependencies = [ + "bolero-generator-derive", + "rand_core 0.9.5", +] + +[[package]] +name = "bolero-generator-derive" +version = "0.13.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a21a3b022507b9edd2050caf370d945e398c1a7c8455531220fa3968c45d29e" +dependencies = [ + "proc-macro-crate 2.0.0", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "bolero-generator-hydro" +version = "0.13.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a78618f55ac4dfa3c66dde097f26105478348b52e985249999c859c250c5719e" +dependencies = [ + "bolero-generator-derive", + "either", + "getrandom 0.3.4", + "rand_core 0.9.5", + "rand_xoshiro", +] + +[[package]] +name = "bolero-honggfuzz" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a118ef27295eddefadc6a99728ee698d1b18d2e80dc4777d21bee3385096ffd" +dependencies = [ + "bolero-engine", +] + +[[package]] +name = "bolero-hydro" +version = "0.13.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef7956e385b91a5aee997d23d40c65ff65af698e71f49ba5f3d87ee99ea4b6f5" +dependencies = [ + "bolero-afl", + "bolero-engine-hydro", + "bolero-generator-hydro", + "bolero-honggfuzz", + "bolero-kani", + "bolero-libfuzzer-hydro", + "cfg-if", + "rand 0.9.2", +] + +[[package]] +name = "bolero-kani" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "852ea5784a9f3e68bfd302ca80b8b863bce140593eb5770fee6ab110899c28fc" +dependencies = [ + "bolero-engine", +] + +[[package]] +name = "bolero-libfuzzer-hydro" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59a4b5c591eff98751f101412e42edac650f417a9fefbe36d3ecb0773009470c" +dependencies = [ + "bolero-engine-hydro", + "cc", +] + [[package]] name = "brotli" version = "8.0.2" @@ -583,9 +698,9 @@ checksum = "64fa3c856b712db6612c019f14756e64e4bcea13337a6b33b696333a9eaa2d06" [[package]] name = "bytemuck" -version = "1.24.0" +version = "1.25.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1fbdf580320f38b612e485521afda1ee26d10cc9884efaaa750d383e13e3c5f4" +checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec" [[package]] name = "byteorder" @@ -595,9 +710,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" [[package]] name = "bytes" -version = "1.11.0" +version = "1.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b35204fbdc0b3f4446b89fc1ac2cf84a8a68971995d0bf2e925ec7cd960f9cb3" +checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33" dependencies = [ "serde", ] @@ -657,14 +772,20 @@ dependencies = [ [[package]] name = "cc" -version = "1.2.54" +version = "1.2.55" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6354c81bbfd62d9cfa9cb3c773c2b7b2a3a482d569de977fd0e961f6e7c00583" +checksum = "47b26a0954ae34af09b50f0de26458fa95369a0d478d8236d3f93082b219bd29" dependencies = [ "find-msvc-tools", "shlex", ] +[[package]] +name = "cc-traits" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "060303ef31ef4a522737e1b1ab68c67916f2a787bb2f4f54f383279adba962b5" + [[package]] name = "cesu8" version = "1.1.0" @@ -739,9 +860,9 @@ dependencies = [ [[package]] name = "clap" -version = "4.5.56" +version = "4.5.57" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a75ca66430e33a14957acc24c5077b503e7d374151b2b4b3a10c83b4ceb4be0e" +checksum = "6899ea499e3fb9305a65d5ebf6e3d2248c5fab291f300ad0a704fbe142eae31a" dependencies = [ "clap_builder", "clap_derive", @@ -749,9 +870,9 @@ dependencies = [ [[package]] name = "clap_builder" -version = "4.5.56" +version = "4.5.57" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "793207c7fa6300a0608d1080b858e5fdbe713cdc1c8db9fb17777d8a13e63df0" +checksum = "7b12c8b680195a62a8364d16b8447b01b6c2c8f9aaf68bee653be34d4245e238" dependencies = [ "anstream", "anstyle", @@ -895,7 +1016,7 @@ dependencies = [ [[package]] name = "copy_span" version = "0.1.0" -source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" +source = "git+https://github.com/hydro-project/hydro.git#efaa8f61c124c4b3c691b92a58df1686751cf45c" dependencies = [ "proc-macro2", "syn", @@ -1114,7 +1235,7 @@ dependencies = [ [[package]] name = "dfir_lang" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" +source = "git+https://github.com/hydro-project/hydro.git#efaa8f61c124c4b3c691b92a58df1686751cf45c" dependencies = [ "auto_impl", "documented", @@ -1129,6 +1250,36 @@ dependencies = [ "syn", ] +[[package]] +name = "dfir_rs" +version = "0.15.0" +source = "git+https://github.com/hydro-project/hydro.git#efaa8f61c124c4b3c691b92a58df1686751cf45c" +dependencies = [ + "bincode", + "bytes", + "dfir_lang", + "futures", + "getrandom 0.2.17", + "hydro_build_utils", + "itertools 0.13.0", + "lattices", + "pin-project-lite", + "ref-cast", + "rustc-hash 1.1.0", + "sealed", + "serde", + "serde_json", + "sinktools", + "slotmap", + "smallvec", + "tokio", + "tokio-stream", + "tokio-util", + "tracing", + "variadics", + "web-time", +] + [[package]] name = "digest" version = "0.10.7" @@ -1392,15 +1543,15 @@ checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d" [[package]] name = "find-msvc-tools" -version = "0.1.8" +version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8591b0bcc8a98a64310a2fae1bb3e9b8564dd10e381e6e28010fde8e8e8568db" +checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" [[package]] name = "flate2" -version = "1.1.8" +version = "1.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b375d6465b98090a5f25b1c7703f3859783755aa9a80433b36e0379a3ec2f369" +checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c" dependencies = [ "crc32fast", "miniz_oxide", @@ -1444,6 +1595,12 @@ dependencies = [ "windows-sys 0.59.0", ] +[[package]] +name = "fst" +version = "0.4.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ab85b9b05e3978cc9a9cf8fea7f01b494e1a09ed3037e16ba39edc7a29eb61a" + [[package]] name = "futures" version = "0.3.31" @@ -1780,7 +1937,7 @@ checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" [[package]] name = "hydro_build_utils" version = "0.0.1" -source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" +source = "git+https://github.com/hydro-project/hydro.git#efaa8f61c124c4b3c691b92a58df1686751cf45c" dependencies = [ "insta", "rustc_version", @@ -1789,7 +1946,7 @@ dependencies = [ [[package]] name = "hydro_deploy" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" +source = "git+https://github.com/hydro-project/hydro.git#efaa8f61c124c4b3c691b92a58df1686751cf45c" dependencies = [ "anyhow", "append-only-vec", @@ -1825,7 +1982,7 @@ dependencies = [ [[package]] name = "hydro_deploy_integration" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" +source = "git+https://github.com/hydro-project/hydro.git#efaa8f61c124c4b3c691b92a58df1686751cf45c" dependencies = [ "async-recursion", "async-trait", @@ -1843,12 +2000,15 @@ dependencies = [ [[package]] name = "hydro_lang" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" +source = "git+https://github.com/hydro-project/hydro.git#efaa8f61c124c4b3c691b92a58df1686751cf45c" dependencies = [ "auto_impl", "backtrace", "bincode", + "bolero-hydro", + "buildstructor", "bytes", + "cargo_metadata", "chrono", "clap", "colored", @@ -1856,15 +2016,19 @@ dependencies = [ "ctor 0.2.9", "data-encoding", "dfir_lang", + "dfir_rs", "flate2", "futures", "hydro_build_utils", "hydro_deploy", "hydro_deploy_integration", + "indenter", "itertools 0.13.0", + "libloading", "nameof", + "pin-project-lite", "prettyplease", - "proc-macro-crate", + "proc-macro-crate 3.4.0", "proc-macro2", "quote", "sealed", @@ -1876,7 +2040,9 @@ dependencies = [ "stageleft", "stageleft_tool", "syn", + "tempfile", "tokio", + "tokio-metrics", "tokio-stream", "tokio-util", "toml", @@ -1894,13 +2060,14 @@ dependencies = [ "clap", "ctor 0.2.9", "good_lp", + "hdrhistogram", "hydro_build_utils", "hydro_deploy", "hydro_lang", "hydro_std", "hydro_test", "include_mdtests", - "proc-macro-crate", + "proc-macro-crate 3.4.0", "proc-macro2", "quote", "regex", @@ -1934,7 +2101,7 @@ dependencies = [ [[package]] name = "hydro_std" version = "0.15.0" -source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" +source = "git+https://github.com/hydro-project/hydro.git#efaa8f61c124c4b3c691b92a58df1686751cf45c" dependencies = [ "hdrhistogram", "hydro_lang", @@ -1946,7 +2113,7 @@ dependencies = [ [[package]] name = "hydro_test" version = "0.0.0" -source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" +source = "git+https://github.com/hydro-project/hydro.git#efaa8f61c124c4b3c691b92a58df1686751cf45c" dependencies = [ "bytes", "colored", @@ -2005,14 +2172,13 @@ dependencies = [ [[package]] name = "hyper-util" -version = "0.1.19" +version = "0.1.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "727805d60e7938b76b826a6ef209eb70eaa1812794f9424d4a4e2d740662df5f" +checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0" dependencies = [ "base64 0.22.1", "bytes", "futures-channel", - "futures-core", "futures-util", "http", "http-body", @@ -2156,7 +2322,7 @@ dependencies = [ [[package]] name = "include_mdtests" version = "0.0.0" -source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" +source = "git+https://github.com/hydro-project/hydro.git#efaa8f61c124c4b3c691b92a58df1686751cf45c" dependencies = [ "glob", "proc-macro2", @@ -2164,6 +2330,12 @@ dependencies = [ "syn", ] +[[package]] +name = "indenter" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "964de6e86d545b246d84badc0fef527924ace5134f30641c203ef52ba83f58d5" + [[package]] name = "indexmap" version = "2.13.0" @@ -2225,9 +2397,9 @@ dependencies = [ [[package]] name = "insta" -version = "1.46.1" +version = "1.46.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "248b42847813a1550dafd15296fd9748c651d0c32194559dbc05d804d54b21e8" +checksum = "e82db8c87c7f1ccecb34ce0c24399b8a73081427f3c7c50a5d597925356115e4" dependencies = [ "console", "once_cell", @@ -2352,6 +2524,34 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "lattices" +version = "0.6.2" +source = "git+https://github.com/hydro-project/hydro.git#efaa8f61c124c4b3c691b92a58df1686751cf45c" +dependencies = [ + "cc-traits", + "fst", + "hydro_build_utils", + "lattices_macro", + "roaring", + "sealed", + "serde", + "variadics", + "variadics_macro", +] + +[[package]] +name = "lattices_macro" +version = "0.5.11" +source = "git+https://github.com/hydro-project/hydro.git#efaa8f61c124c4b3c691b92a58df1686751cf45c" +dependencies = [ + "hydro_build_utils", + "proc-macro-crate 3.4.0", + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "lazy_static" version = "1.5.0" @@ -3138,9 +3338,9 @@ dependencies = [ [[package]] name = "portable-atomic" -version = "1.13.0" +version = "1.13.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f89776e4d69bb58bc6993e99ffa1d11f228b839984854c7daeb5d37f87cbe950" +checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49" [[package]] name = "potential_utf" @@ -3166,6 +3366,12 @@ dependencies = [ "zerocopy", ] +[[package]] +name = "pretty-hex" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbc83ee4a840062f368f9096d80077a9841ec117e17e7f700df81958f1451254" + [[package]] name = "prettyplease" version = "0.2.37" @@ -3185,6 +3391,15 @@ dependencies = [ "elliptic-curve", ] +[[package]] +name = "proc-macro-crate" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e8366a6159044a37876a2b9817124296703c586a5c92e2c53751fa06d8d43e8" +dependencies = [ + "toml_edit 0.20.7", +] + [[package]] name = "proc-macro-crate" version = "3.4.0" @@ -3245,7 +3460,7 @@ dependencies = [ "pin-project-lite", "quinn-proto", "quinn-udp", - "rustc-hash", + "rustc-hash 2.1.1", "rustls", "socket2", "thiserror 2.0.18", @@ -3265,7 +3480,7 @@ dependencies = [ "lru-slab", "rand 0.9.2", "ring", - "rustc-hash", + "rustc-hash 2.1.1", "rustls", "rustls-pki-types", "slab", @@ -3363,6 +3578,15 @@ dependencies = [ "getrandom 0.3.4", ] +[[package]] +name = "rand_xoshiro" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f703f4665700daf5512dcca5f43afa6af89f09db47fb56be587f80636bda2d41" +dependencies = [ + "rand_core 0.9.5", +] + [[package]] name = "range-collections" version = "0.4.6" @@ -3423,9 +3647,9 @@ dependencies = [ [[package]] name = "regex" -version = "1.12.2" +version = "1.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4" +checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276" dependencies = [ "aho-corasick", "memchr", @@ -3435,9 +3659,9 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.4.13" +version = "0.4.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c" +checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f" dependencies = [ "aho-corasick", "memchr", @@ -3446,9 +3670,9 @@ dependencies = [ [[package]] name = "regex-syntax" -version = "0.8.8" +version = "0.8.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58" +checksum = "a96887878f22d7bad8a3b6dc5b7440e0ada9a245242924394987b21cf2210a4c" [[package]] name = "reqwest" @@ -3524,6 +3748,16 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "roaring" +version = "0.10.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19e8d2cfa184d94d0726d650a9f4a1be7f9b76ac9fdb954219878dc00c1c1e7b" +dependencies = [ + "bytemuck", + "byteorder", +] + [[package]] name = "rsa" version = "0.9.10" @@ -3657,6 +3891,12 @@ version = "0.1.27" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b50b8869d9fc858ce7266cce0194bd74df58b9d0e3f6df3a9fc8eb470d95c09d" +[[package]] +name = "rustc-hash" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" + [[package]] name = "rustc-hash" version = "2.1.1" @@ -4005,7 +4245,7 @@ checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa" [[package]] name = "sinktools" version = "0.0.1" -source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" +source = "git+https://github.com/hydro-project/hydro.git#efaa8f61c124c4b3c691b92a58df1686751cf45c" dependencies = [ "futures-util", "pin-project-lite", @@ -4022,9 +4262,9 @@ checksum = "b2aa850e253778c88a04c3d7323b043aeda9d3e30d5971937c1855769763678e" [[package]] name = "slab" -version = "0.4.11" +version = "0.4.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" [[package]] name = "slotmap" @@ -4115,12 +4355,12 @@ checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" [[package]] name = "stageleft" -version = "0.13.0" +version = "0.13.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36eaefb60f9f46e22a155170c369356ce23f7f86f66e262247215a9d38a5b20a" +checksum = "5515c966d11023237b528433ed874b94f81d8fd1d960182758946948584ad348" dependencies = [ "ctor 0.4.3", - "proc-macro-crate", + "proc-macro-crate 3.4.0", "proc-macro2", "quote", "stageleft_macro", @@ -4129,11 +4369,11 @@ dependencies = [ [[package]] name = "stageleft_macro" -version = "0.13.0" +version = "0.13.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49d0693d2610bb355238fb72ff5ab1ad75523314cca9f5896338f75342715213" +checksum = "22b9d1c1c018fa785a5298bee5d876bba170e8abf8859c9d6c4d4f1ce61f6758" dependencies = [ - "proc-macro-crate", + "proc-macro-crate 3.4.0", "proc-macro2", "quote", "sha2", @@ -4142,12 +4382,12 @@ dependencies = [ [[package]] name = "stageleft_tool" -version = "0.13.0" +version = "0.13.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c0507e668793592e373859d47549ce55b45fff3a475385ea1d9d2f42139a3d3" +checksum = "3d611f80971adc49ae8a47372f785a3047df3b4cb7c56c3e9f8b920cedc5075a" dependencies = [ "prettyplease", - "proc-macro-crate", + "proc-macro-crate 3.4.0", "proc-macro2", "quote", "sha2", @@ -4428,6 +4668,18 @@ dependencies = [ "syn", ] +[[package]] +name = "tokio-metrics" +version = "0.4.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f4c2ca6283a34abc77cb58ea83d4a3c40e0162b0095d7a674172a2eed5415197" +dependencies = [ + "futures-util", + "pin-project-lite", + "tokio", + "tokio-stream", +] + [[package]] name = "tokio-rustls" version = "0.26.4" @@ -4475,7 +4727,7 @@ dependencies = [ "toml_datetime 0.7.5+spec-1.1.0", "toml_parser", "toml_writer", - "winnow", + "winnow 0.7.14", ] [[package]] @@ -4493,6 +4745,17 @@ dependencies = [ "serde_core", ] +[[package]] +name = "toml_edit" +version = "0.20.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70f427fce4d84c72b5b732388bf4a9f4531b53f74e2887e3ecb2481f68f66d81" +dependencies = [ + "indexmap", + "toml_datetime 0.6.11", + "winnow 0.5.40", +] + [[package]] name = "toml_edit" version = "0.22.27" @@ -4502,7 +4765,7 @@ dependencies = [ "indexmap", "toml_datetime 0.6.11", "toml_write", - "winnow", + "winnow 0.7.14", ] [[package]] @@ -4514,7 +4777,7 @@ dependencies = [ "indexmap", "toml_datetime 0.7.5+spec-1.1.0", "toml_parser", - "winnow", + "winnow 0.7.14", ] [[package]] @@ -4523,7 +4786,7 @@ version = "1.0.6+spec-1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a3198b4b0a8e11f09dd03e133c0280504d0801269e9afa46362ffde1cbeebf44" dependencies = [ - "winnow", + "winnow 0.7.14", ] [[package]] @@ -4789,13 +5052,25 @@ checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" [[package]] name = "variadics" version = "0.0.10" -source = "git+https://github.com/hydro-project/hydro.git#c9016c90937354abe6dd28558cd52e1e37a6389d" +source = "git+https://github.com/hydro-project/hydro.git#efaa8f61c124c4b3c691b92a58df1686751cf45c" dependencies = [ "hashbrown 0.14.5", "hydro_build_utils", "sealed", ] +[[package]] +name = "variadics_macro" +version = "0.6.2" +source = "git+https://github.com/hydro-project/hydro.git#efaa8f61c124c4b3c691b92a58df1686751cf45c" +dependencies = [ + "proc-macro-crate 3.4.0", + "proc-macro2", + "quote", + "syn", + "variadics", +] + [[package]] name = "version_check" version = "0.9.5" @@ -4946,9 +5221,9 @@ dependencies = [ [[package]] name = "webpki-roots" -version = "1.0.5" +version = "1.0.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "12bed680863276c63889429bfd6cab3b99943659923822de1c8a39c49e4d722c" +checksum = "22cfaf3c063993ff62e73cb4311efde4db1efb31ab78a3e5c457939ad5cc0bed" dependencies = [ "rustls-pki-types", ] @@ -5377,6 +5652,15 @@ version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650" +[[package]] +name = "winnow" +version = "0.5.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876" +dependencies = [ + "memchr", +] + [[package]] name = "winnow" version = "0.7.14" @@ -5429,18 +5713,18 @@ dependencies = [ [[package]] name = "zerocopy" -version = "0.8.36" +version = "0.8.38" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dafd85c832c1b68bbb4ec0c72c7f6f4fc5179627d2bc7c26b30e4c0cc11e76cc" +checksum = "57cf3aa6855b23711ee9852dfc97dfaa51c45feaba5b645d0c777414d494a961" dependencies = [ "zerocopy-derive", ] [[package]] name = "zerocopy-derive" -version = "0.8.36" +version = "0.8.38" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7cb7e4e8436d9db52fbd6625dbf2f45243ab84994a72882ec8227b99e72b439a" +checksum = "8a616990af1a287837c4fe6596ad77ef57948f787e46ce28e166facc0cc1cb75" dependencies = [ "proc-macro2", "quote", @@ -5509,12 +5793,12 @@ dependencies = [ [[package]] name = "zlib-rs" -version = "0.5.5" +version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "40990edd51aae2c2b6907af74ffb635029d5788228222c4bb811e9351c0caad3" +checksum = "a7948af682ccbc3342b6e9420e8c51c1fe5d7bf7756002b4a3c6cabfe96a7e3c" [[package]] name = "zmij" -version = "1.0.17" +version = "1.0.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "02aae0f83f69aafc94776e879363e9771d7ecbffe2c7fbb6c14c5e00dfe88439" +checksum = "3ff05f8caa9038894637571ae6b9e29466c1f4f829d26c9b28f869a29cbe3445" diff --git a/hydro_optimize/Cargo.toml b/hydro_optimize/Cargo.toml index cdd8348..aa83c75 100644 --- a/hydro_optimize/Cargo.toml +++ b/hydro_optimize/Cargo.toml @@ -11,8 +11,10 @@ all-features = true [dependencies] good_lp = { version = "1.14.0", features = ["highs"], default-features = false } +hdrhistogram = "7.5.4" hydro_deploy.workspace = true hydro_lang = { workspace = true, features = ["deploy"] } +hydro_std.workspace = true proc-macro2 = "1.0.95" regex.workspace = true serde.workspace = true @@ -31,7 +33,6 @@ ctor.workspace = true hydro_build_utils.workspace = true hydro_lang = { workspace = true, features = ["viz"] } hydro_test.workspace = true -hydro_std.workspace = true clap.workspace = true include_mdtests.workspace = true diff --git a/hydro_optimize/src/deploy_and_analyze.rs b/hydro_optimize/src/deploy_and_analyze.rs index a12f313..dabf7f1 100644 --- a/hydro_optimize/src/deploy_and_analyze.rs +++ b/hydro_optimize/src/deploy_and_analyze.rs @@ -25,7 +25,7 @@ const COUNTER_PREFIX: &str = "_optimize_counter"; pub(crate) const CPU_USAGE_PREFIX: &str = "HYDRO_OPTIMIZE_CPU:"; pub(crate) const NETWORK_USAGE_PREFIX: &str = "HYDRO_OPTIMIZE_NET:"; pub(crate) const LATENCY_PREFIX: &str = "HYDRO_OPTIMIZE_LAT:"; -pub(crate) const THROUGHPUT_PREFIX: &str = "HYDRO_OPTIMIZE_THR:"; +pub const THROUGHPUT_PREFIX: &str = "HYDRO_OPTIMIZE_THR:"; // Note: Ensure edits to the match arms are consistent with inject_count_node fn insert_counter_node(node: &mut HydroNode, next_stmt_id: &mut usize, duration: syn::Expr) { diff --git a/hydro_optimize/src/parse_results.rs b/hydro_optimize/src/parse_results.rs index 956be44..219d705 100644 --- a/hydro_optimize/src/parse_results.rs +++ b/hydro_optimize/src/parse_results.rs @@ -1,12 +1,17 @@ use std::collections::HashMap; +use std::time::Duration; use crate::deploy_and_analyze::{LATENCY_PREFIX, THROUGHPUT_PREFIX}; +use hdrhistogram::Histogram; use hydro_lang::compile::deploy::DeployResult; use hydro_lang::compile::ir::{HydroNode, HydroRoot, traverse_dfir}; use hydro_lang::deploy::HydroDeploy; use hydro_lang::deploy::deploy_graph::DeployCrateWrapper; use hydro_lang::location::dynamic::LocationId; +use hydro_std::bench_client::AggregateBenchResult; +use hydro_std::bench_client::rolling_average::RollingAverage; use regex::Regex; +use stageleft::q; use tokio::sync::mpsc::UnboundedReceiver; use crate::deploy_and_analyze::MetricLogs; @@ -105,7 +110,10 @@ pub fn print_parseable_bench_results<'a, Aggregator>( ) { aggregate_results .throughput - .filter_map(q!(move |(throughputs, num_client_machines)| { + .filter_map(q!(move |(throughputs, num_client_machines): ( + RollingAverage, + usize + )| { if let Some((lower, upper)) = throughputs.confidence_interval_99() { Some(( lower * num_client_machines as f64, @@ -116,7 +124,7 @@ pub fn print_parseable_bench_results<'a, Aggregator>( None } })) - .for_each(q!(|(lower, mean, upper)| { + .for_each(q!(move |(lower, mean, upper)| { println!( "{} {:.2} - {:.2} - {:.2} requests/s", THROUGHPUT_PREFIX, lower, mean, upper, @@ -124,7 +132,7 @@ pub fn print_parseable_bench_results<'a, Aggregator>( })); aggregate_results .latency - .map(q!(move |latencies| ( + .map(q!(move |latencies: Histogram| ( Duration::from_nanos(latencies.value_at_quantile(0.5)).as_micros() as f64 / interval_millis as f64, Duration::from_nanos(latencies.value_at_quantile(0.99)).as_micros() as f64 @@ -362,7 +370,7 @@ pub async fn analyze_process_results( ir: &mut [HydroRoot], op_to_count: &mut HashMap, metrics: &mut MetricLogs, -) -> (u64, NetworkStats) { +) -> (f64, NetworkStats) { let underlying = process.underlying(); let perf_results = underlying.tracing_results().unwrap(); @@ -427,7 +435,7 @@ pub async fn analyze_cluster_results( run_metadata.total_usage.insert(id.clone(), usage); run_metadata .unaccounted_perf - .insert(id.clone(), unidentified_perf as f64); + .insert(id.clone(), unidentified_perf); run_metadata .network_stats .insert(id.clone(), network_stats.clone()); diff --git a/hydro_optimize_examples/Cargo.toml b/hydro_optimize_examples/Cargo.toml index 342f76c..19dc137 100644 --- a/hydro_optimize_examples/Cargo.toml +++ b/hydro_optimize_examples/Cargo.toml @@ -11,6 +11,7 @@ all-features = true hydro_lang.workspace = true hydro_std.workspace = true hydro_test.workspace = true +hydro_optimize = { path = "../hydro_optimize" } serde.workspace = true sha2 = "0.10.9" stageleft.workspace = true @@ -22,8 +23,7 @@ clap.workspace = true dfir_lang.workspace = true hydro_build_utils.workspace = true hydro_deploy.workspace = true -hydro_lang = { workspace = true, features = ["deploy", "viz"] } -hydro_optimize = { path = "../hydro_optimize" } +hydro_lang = { workspace = true, features = ["deploy", "viz", "sim"] } regex.workspace = true [build-dependencies] diff --git a/hydro_optimize_examples/examples/perf_paxos.rs b/hydro_optimize_examples/examples/perf_paxos.rs index 7987790..e40e93d 100644 --- a/hydro_optimize_examples/examples/perf_paxos.rs +++ b/hydro_optimize_examples/examples/perf_paxos.rs @@ -5,6 +5,7 @@ use hydro_optimize::deploy::{HostType, ReusableHosts}; use hydro_optimize::deploy_and_analyze::{ Optimizations, ReusableClusters, ReusableProcesses, deploy_and_optimize, }; +use hydro_optimize::parse_results::print_parseable_bench_results; use hydro_test::cluster::paxos::{CorePaxos, PaxosConfig}; use hydro_test::cluster::paxos_bench::{Aggregator, Client}; diff --git a/hydro_optimize_examples/src/network_calibrator.rs b/hydro_optimize_examples/src/network_calibrator.rs index eaee198..5a6360c 100644 --- a/hydro_optimize_examples/src/network_calibrator.rs +++ b/hydro_optimize_examples/src/network_calibrator.rs @@ -3,7 +3,8 @@ use hydro_lang::{ nondet::nondet, prelude::{Cluster, KeyedStream, Process, TCP, Unbounded}, }; -use hydro_std::bench_client::{bench_client, compute_throughput_latency, print_bench_results}; +use hydro_optimize::parse_results::print_parseable_bench_results; +use hydro_std::bench_client::{aggregate_bench_results, bench_client, compute_throughput_latency}; use stageleft::q; @@ -17,6 +18,7 @@ pub fn network_calibrator<'a>( server: &Cluster<'a, Server>, clients: &Cluster<'a, Client>, client_aggregator: &Process<'a, Aggregator>, + interval_millis: u64, ) { let latencies = bench_client( clients, @@ -36,7 +38,8 @@ pub fn network_calibrator<'a>( ).values().map(q!(|(_client_id, latency)| latency)); let bench_results = compute_throughput_latency(clients, latencies, nondet!(/** bench */)); - print_bench_results(bench_results, client_aggregator, clients); + let aggregate_results = aggregate_bench_results(bench_results, client_aggregator, clients, interval_millis); + print_parseable_bench_results(aggregate_results, interval_millis); } /// Generates an incrementing u32 for each virtual client ID, starting at 0 diff --git a/hydro_optimize_examples/src/simple_kv_bench.rs b/hydro_optimize_examples/src/simple_kv_bench.rs index 4a22a8e..29a0e44 100644 --- a/hydro_optimize_examples/src/simple_kv_bench.rs +++ b/hydro_optimize_examples/src/simple_kv_bench.rs @@ -3,7 +3,8 @@ use hydro_lang::{ nondet::nondet, prelude::{Cluster, Process, TCP}, }; -use hydro_std::bench_client::{bench_client, compute_throughput_latency, print_bench_results}; +use hydro_optimize::parse_results::print_parseable_bench_results; +use hydro_std::bench_client::{aggregate_bench_results, bench_client, compute_throughput_latency}; use hydro_test::cluster::paxos_bench::inc_i32_workload_generator; use stageleft::q; @@ -17,40 +18,52 @@ pub fn simple_kv_bench<'a>( kv: &Process<'a, Kv>, clients: &Cluster<'a, Client>, client_aggregator: &Process<'a, Aggregator>, + interval_millis: u64, ) { - let latencies = bench_client(clients, num_clients_per_node, inc_i32_workload_generator, |input| { - let k_tick = kv.tick(); - // Use atomic to prevent outputting to the client before values are inserted to the KV store - let k_payloads = input.send(kv, TCP.bincode()).atomic(&k_tick); - - let for_each_tick = kv.tick(); - // Insert each payload into the KV store - k_payloads - .clone() - .assume_ordering(nondet!(/** Last writer wins per key. */)) - // Persist state across ticks - .reduce(q!(|prev, new| { - *prev = new; - })) - .end_atomic() - .snapshot( - &for_each_tick, - nondet!(/** for_each does nothing, just need to end on a HydroRoot */), - ) - .entries() - .all_ticks() - .assume_ordering(nondet!(/** for_each does nothing, just need to end on a HydroRoot */)) - .assume_retries(nondet!(/** for_each does nothing, just need to end on a HydroRoot */)) - .for_each(q!(|_| {})); // Do nothing, just need to end on a HydroRoot - - // Send committed requests back to the original client - k_payloads - .end_atomic() - .demux(clients, TCP.bincode()) - }).values().map(q!(|(_value, latency)| latency)); + let latencies = bench_client( + clients, + num_clients_per_node, + inc_i32_workload_generator, + |input| { + let k_tick = kv.tick(); + // Use atomic to prevent outputting to the client before values are inserted to the KV store + let k_payloads = input.send(kv, TCP.bincode()).atomic(&k_tick); + + let for_each_tick = kv.tick(); + // Insert each payload into the KV store + k_payloads + .clone() + .assume_ordering(nondet!(/** Last writer wins per key. */)) + // Persist state across ticks + .reduce(q!(|prev, new| { + *prev = new; + })) + .end_atomic() + .snapshot( + &for_each_tick, + nondet!(/** for_each does nothing, just need to end on a HydroRoot */), + ) + .entries() + .all_ticks() + .assume_ordering( + nondet!(/** for_each does nothing, just need to end on a HydroRoot */), + ) + .assume_retries( + nondet!(/** for_each does nothing, just need to end on a HydroRoot */), + ) + .for_each(q!(|_| {})); // Do nothing, just need to end on a HydroRoot + + // Send committed requests back to the original client + k_payloads.end_atomic().demux(clients, TCP.bincode()) + }, + ) + .values() + .map(q!(|(_value, latency)| latency)); let bench_results = compute_throughput_latency(clients, latencies, nondet!(/** bench */)); - print_bench_results(bench_results, client_aggregator, clients); + let aggregate_results = + aggregate_bench_results(bench_results, client_aggregator, clients, interval_millis); + print_parseable_bench_results(aggregate_results, interval_millis); } #[cfg(test)] @@ -63,6 +76,7 @@ mod tests { deploy::{DeployCrateWrapper, HydroDeploy, TrybuildHost}, prelude::FlowBuilder, }; + use hydro_optimize::deploy_and_analyze::THROUGHPUT_PREFIX; use std::str::FromStr; use regex::Regex; @@ -76,8 +90,9 @@ mod tests { let kv = builder.process(); let clients = builder.cluster(); let client_aggregator = builder.process(); + let interval_millis = 1000; - simple_kv_bench(1, &kv, &clients, &client_aggregator); + simple_kv_bench(1, &kv, &clients, &client_aggregator, interval_millis); let mut built = builder.with_default_optimize::(); dbg_dedup_tee(|| { @@ -104,8 +119,9 @@ mod tests { let kv = builder.process(); let clients = builder.cluster(); let client_aggregator = builder.process(); + let interval_millis = 1000; - simple_kv_bench(1, &kv, &clients, &client_aggregator); + simple_kv_bench(1, &kv, &clients, &client_aggregator, interval_millis); let mut deployment = Deployment::new(); let nodes = builder @@ -120,11 +136,11 @@ mod tests { deployment.deploy().await.unwrap(); let client_node = &nodes.get_process(&client_aggregator); - let client_out = client_node.stdout_filter("Throughput:"); + let client_out = client_node.stdout_filter(THROUGHPUT_PREFIX); deployment.start().await.unwrap(); - let re = Regex::new(r"Throughput: ([^ ]+) - ([^ ]+) - ([^ ]+) requests/s").unwrap(); + let re = Regex::new(r"(\d+\.?\d*)\s*-\s*(\d+\.?\d*)\s*-\s*(\d+\.?\d*)\s*requests/s").unwrap(); let mut found = 0; let mut client_out = client_out; while let Some(line) = client_out.recv().await { From 12fb94962f4de22d0a9d560a63cbcdbf024806ed Mon Sep 17 00:00:00 2001 From: David Chu Date: Tue, 3 Feb 2026 15:22:59 -0800 Subject: [PATCH 30/35] More fixes, remove fragile tests --- Cargo.lock | 1 + hydro_optimize/Cargo.toml | 1 + hydro_optimize/build.rs | 3 + hydro_optimize/src/lib.rs | 5 +- hydro_optimize/src/tests/mod.rs | 67 - ...imize__tests__decoupled_compute_pi_ir.snap | 445 - ...coupled_compute_pi_ir@surface_graph_0.snap | 18 - ...coupled_compute_pi_ir@surface_graph_1.snap | 32 - ...coupled_compute_pi_ir@surface_graph_2.snap | 20 - ..._tests__partitioned_simple_cluster_ir.snap | 263 - ...ned_simple_cluster_ir@surface_graph_0.snap | 31 - ...ned_simple_cluster_ir@surface_graph_1.snap | 14 - ..._two_pc__two_pc_partition_coordinator.snap | 18378 ---------------- ..._two_pc__two_pc_partition_participant.snap | 18115 --------------- hydro_optimize/src/tests/two_pc.rs | 138 - .../examples/network_calibrator.rs | 2 + .../examples/partition_two_pc.rs | 1 + .../examples/perf_paxos.rs | 4 +- 18 files changed, 12 insertions(+), 37526 deletions(-) create mode 100644 hydro_optimize/build.rs delete mode 100644 hydro_optimize/src/tests/mod.rs delete mode 100644 hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir.snap delete mode 100644 hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir@surface_graph_0.snap delete mode 100644 hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir@surface_graph_1.snap delete mode 100644 hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir@surface_graph_2.snap delete mode 100644 hydro_optimize/src/tests/snapshots/hydro_optimize__tests__partitioned_simple_cluster_ir.snap delete mode 100644 hydro_optimize/src/tests/snapshots/hydro_optimize__tests__partitioned_simple_cluster_ir@surface_graph_0.snap delete mode 100644 hydro_optimize/src/tests/snapshots/hydro_optimize__tests__partitioned_simple_cluster_ir@surface_graph_1.snap delete mode 100644 hydro_optimize/src/tests/snapshots/hydro_optimize__tests__two_pc__two_pc_partition_coordinator.snap delete mode 100644 hydro_optimize/src/tests/snapshots/hydro_optimize__tests__two_pc__two_pc_partition_participant.snap delete mode 100644 hydro_optimize/src/tests/two_pc.rs diff --git a/Cargo.lock b/Cargo.lock index 934d893..1dc9717 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2073,6 +2073,7 @@ dependencies = [ "regex", "serde", "stageleft", + "stageleft_tool", "syn", "tokio", ] diff --git a/hydro_optimize/Cargo.toml b/hydro_optimize/Cargo.toml index aa83c75..54bcbe4 100644 --- a/hydro_optimize/Cargo.toml +++ b/hydro_optimize/Cargo.toml @@ -37,4 +37,5 @@ clap.workspace = true include_mdtests.workspace = true [build-dependencies] +stageleft_tool.workspace = true hydro_build_utils.workspace = true \ No newline at end of file diff --git a/hydro_optimize/build.rs b/hydro_optimize/build.rs new file mode 100644 index 0000000..99775c3 --- /dev/null +++ b/hydro_optimize/build.rs @@ -0,0 +1,3 @@ +fn main() { + stageleft_tool::gen_final!(); +} diff --git a/hydro_optimize/src/lib.rs b/hydro_optimize/src/lib.rs index 7b39bf9..20c7122 100644 --- a/hydro_optimize/src/lib.rs +++ b/hydro_optimize/src/lib.rs @@ -1,3 +1,5 @@ +stageleft::stageleft_no_entry_crate!(); + pub mod debug; pub mod decouple_analysis; pub mod decoupler; @@ -10,9 +12,6 @@ pub mod partitioner; pub mod repair; pub mod rewrites; -#[cfg(test)] -mod tests; - #[doc(hidden)] #[cfg(doctest)] mod docs { diff --git a/hydro_optimize/src/tests/mod.rs b/hydro_optimize/src/tests/mod.rs deleted file mode 100644 index 422f852..0000000 --- a/hydro_optimize/src/tests/mod.rs +++ /dev/null @@ -1,67 +0,0 @@ -use std::collections::HashMap; - -use hydro_build_utils::insta; -use hydro_lang::deploy::HydroDeploy; -use hydro_lang::location::Location; -use hydro_lang::prelude::*; - -use crate::decoupler::{self, DecoupleDecision}; -use crate::partitioner::Partitioner; - -mod two_pc; - -struct DecoupledCluster; - -#[test] -fn decoupled_compute_pi_ir() { - let mut builder = FlowBuilder::new(); - let (cluster, _) = hydro_test::cluster::compute_pi::compute_pi(&mut builder, 8192); - let decoupled_cluster = builder.cluster::(); - let decoupler = decoupler::Decoupler { - decision: DecoupleDecision { - output_to_decoupled_machine_after: vec![4], - output_to_original_machine_after: vec![], - place_on_decoupled_machine: vec![], - }, - decoupled_location: decoupled_cluster.id().clone(), - orig_location: cluster.id().clone(), - }; - let mut built = builder - .optimize_with(|roots| decoupler::decouple(roots, &decoupler)) - .into_deploy::(); - - insta::assert_debug_snapshot!(built.ir()); - - for (id, ir) in built.preview_compile().all_dfir() { - insta::with_settings!({ - snapshot_suffix => format!("surface_graph_{id}"), - }, { - insta::assert_snapshot!(ir.surface_syntax_string()); - }); - } -} - -#[test] -fn partitioned_simple_cluster_ir() { - let mut builder = FlowBuilder::new(); - let (_, cluster) = hydro_test::cluster::simple_cluster::simple_cluster(&mut builder); - let partitioner = Partitioner { - nodes_to_partition: HashMap::from([(5, vec!["1".to_string()])]), - num_partitions: 3, - location_id: cluster.id().key(), - new_cluster_id: None, - }; - let mut built = builder - .optimize_with(|roots| crate::partitioner::partition(roots, &partitioner)) - .into_deploy::(); - - insta::assert_debug_snapshot!(built.ir()); - - for (id, ir) in built.preview_compile().all_dfir() { - insta::with_settings!({ - snapshot_suffix => format!("surface_graph_{id}") - }, { - insta::assert_snapshot!(ir.surface_syntax_string()); - }); - } -} diff --git a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir.snap b/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir.snap deleted file mode 100644 index 78ed060..0000000 --- a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir.snap +++ /dev/null @@ -1,445 +0,0 @@ ---- -source: hydro_optimize/src/tests/mod.rs -expression: built.ir() ---- -[ - ForEach { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u64 , u64) , () > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: compute_pi :: * ; | (inside , total) | { println ! ("pi: {} ({} trials)" , 4.0 * inside as f64 / total as f64 , total) ; } }), - input: ObserveNonDet { - inner: Cast { - inner: YieldConcat { - inner: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((u64 , u64) , ()) , (u64 , u64) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Batch { - inner: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (u64 , u64) , (u64 , u64) , () > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: compute_pi :: * ; | (inside , total) , (inside_batch , total_batch) | { * inside += inside_batch ; * total += total_batch ; } }), - input: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: compute_pi :: Worker > , (u64 , u64)) , (u64 , u64) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (u64 , u64) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: compute_pi :: Worker > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u64 , u64) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < (u64 , u64) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: compute_pi :: * ; | | (0u64 , 0u64) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (u64 , u64) , bool , () > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: compute_pi :: * ; | (inside , total) , sample_inside | { if sample_inside { * inside += 1 ; } * total += 1 ; } }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (f64 , f64) , bool > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: compute_pi :: * ; | (x , y) | x * x + y * y < 1.0 }), - input: Map { - f: | (_ , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (f64 , f64)) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (f64 , f64) > (& b) . unwrap ()) }, - ), - input: Map { - f: | b | (:: hydro_lang :: location :: MemberId :: < () > :: from_tagless (__hydro_lang_cluster_self_id_0 . clone ()) , b), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < () , (f64 , f64) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: compute_pi :: * ; | _ | rand :: random :: < (f64 , f64) > () }), - input: Batch { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < usize , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: tick :: * ; | _ | () }), - input: FlatMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < () , std :: ops :: Range < usize > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: tick :: * ; let batch_size__free = { use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: compute_pi :: * ; let batch_size__free = 8192usize ; batch_size__free } ; move | _ | 0 .. batch_size__free }), - input: Source { - source: Spin, - metadata: HydroIrMetadata { - location_id: Cluster( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (f64 , f64), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (f64 , f64), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (f64 , f64), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (f64 , f64), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 2, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: (u64 , u64), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u64 , u64), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u64 , u64), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: compute_pi :: Worker > , (u64 , u64)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: compute_pi :: Worker >, - value_type: (u64 , u64), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: compute_pi :: Worker > , (u64 , u64)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u64 , u64), - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Process( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u64 , u64), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 1, - ), - collection_kind: Optional { - bound: Unbounded, - element_type: (u64 , u64), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 1, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (u64 , u64), - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | _u | () }), - input: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ , _ | { } }), - input: Batch { - inner: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: compute_pi :: * ; Duration :: from_secs (1) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Process( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 1, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 1, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 1, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: ((u64 , u64) , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 1, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (u64 , u64), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u64 , u64), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u64 , u64), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: (u64 , u64), - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Process( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u64 , u64), - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, -] diff --git a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir@surface_graph_0.snap b/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir@surface_graph_0.snap deleted file mode 100644 index 94ca922..0000000 --- a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir@surface_graph_0.snap +++ /dev/null @@ -1,18 +0,0 @@ ---- -source: hydro_optimize/src/tests/mod.rs -expression: ir.surface_syntax_string() ---- -1v1 = spin (); -2v1 = flat_map (stageleft :: runtime_support :: fn1_type_hint :: < () , std :: ops :: Range < usize > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: tick :: * ; let batch_size__free = { use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: compute_pi :: * ; let batch_size__free = 8192usize ; batch_size__free } ; move | _ | 0 .. batch_size__free })); -3v1 = map (stageleft :: runtime_support :: fn1_type_hint :: < usize , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: tick :: * ; | _ | () })); -4v1 = map (stageleft :: runtime_support :: fn1_type_hint :: < () , (f64 , f64) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: compute_pi :: * ; | _ | rand :: random :: < (f64 , f64) > () })); -5v1 = map (| b | (:: hydro_lang :: location :: MemberId :: < () > :: from_tagless (__hydro_lang_cluster_self_id_0 . clone ()) , b)); -6v1 = map (:: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (f64 , f64)) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) })); -7v1 = dest_sink (DUMMY_SINK); - -1v1 -> 2v1; -2v1 -> 3v1; -3v1 -> 4v1; -4v1 -> 5v1; -6v1 -> 7v1; -5v1 -> 6v1; diff --git a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir@surface_graph_1.snap b/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir@surface_graph_1.snap deleted file mode 100644 index 03ebc36..0000000 --- a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir@surface_graph_1.snap +++ /dev/null @@ -1,32 +0,0 @@ ---- -source: hydro_optimize/src/tests/mod.rs -expression: ir.surface_syntax_string() ---- -1v1 = source_stream (DUMMY_SOURCE); -2v1 = map (| res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: compute_pi :: Worker > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u64 , u64) > (& b) . unwrap ()) }); -3v1 = map (stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: compute_pi :: Worker > , (u64 , u64)) , (u64 , u64) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v })); -4v1 = reduce :: < 'static > (stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (u64 , u64) , (u64 , u64) , () > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: compute_pi :: * ; | (inside , total) , (inside_batch , total_batch) | { * inside += inside_batch ; * total += total_batch ; } })); -5v1 = source_stream ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: compute_pi :: * ; Duration :: from_secs (1) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }); -6v1 = reduce :: < 'tick > (stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ , _ | { } })); -7v1 = map (stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | _u | () })); -8v1 = cross_singleton (); -9v1 = map (stageleft :: runtime_support :: fn1_type_hint :: < ((u64 , u64) , ()) , (u64 , u64) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | (d , _signal) | d })); -10v1 = for_each (stageleft :: runtime_support :: fn1_type_hint :: < (u64 , u64) , () > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: compute_pi :: * ; | (inside , total) | { println ! ("pi: {} ({} trials)" , 4.0 * inside as f64 / total as f64 , total) ; } })); -// 11v1 = ; -// 12v1 = ; -// 13v1 = ; -// 14v1 = ; - -1v1 -> 2v1; -2v1 -> 3v1; -3v1 -> 11v1; -5v1 -> 12v1; -6v1 -> 13v1; -4v1 -> 8v1; -7v1 -> 14v1; -8v1 -> 9v1; -9v1 -> 10v1; -11v1 -> 4v1; -12v1 -> 6v1; -13v1 -> 7v1; -14v1 -> 8v1; diff --git a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir@surface_graph_2.snap b/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir@surface_graph_2.snap deleted file mode 100644 index d30c232..0000000 --- a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__decoupled_compute_pi_ir@surface_graph_2.snap +++ /dev/null @@ -1,20 +0,0 @@ ---- -source: hydro_optimize/src/tests/mod.rs -expression: ir.surface_syntax_string() ---- -1v1 = source_stream (DUMMY_SOURCE); -2v1 = map (| res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (f64 , f64) > (& b) . unwrap ()) }); -3v1 = map (| (_ , b) | b); -4v1 = map (stageleft :: runtime_support :: fn1_type_hint :: < (f64 , f64) , bool > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: compute_pi :: * ; | (x , y) | x * x + y * y < 1.0 })); -5v1 = fold :: < 'tick > (stageleft :: runtime_support :: fn0_type_hint :: < (u64 , u64) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: compute_pi :: * ; | | (0u64 , 0u64) }) , stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (u64 , u64) , bool , () > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: compute_pi :: * ; | (inside , total) , sample_inside | { if sample_inside { * inside += 1 ; } * total += 1 ; } })); -6v1 = map (:: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (u64 , u64) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () })); -7v1 = dest_sink (DUMMY_SINK); -// 8v1 = ; - -1v1 -> 2v1; -2v1 -> 3v1; -3v1 -> 4v1; -4v1 -> 8v1; -6v1 -> 7v1; -5v1 -> 6v1; -8v1 -> 5v1; diff --git a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__partitioned_simple_cluster_ir.snap b/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__partitioned_simple_cluster_ir.snap deleted file mode 100644 index 435417e..0000000 --- a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__partitioned_simple_cluster_ir.snap +++ /dev/null @@ -1,263 +0,0 @@ ---- -source: hydro_optimize/src/tests/mod.rs -expression: built.ir() ---- -[ - ForEach { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32)) , () > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: simple_cluster :: * ; | (id , d) | println ! ("node received: ({}, {:?})" , id , d) }), - input: ObserveNonDet { - inner: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32) > (& b) . unwrap ()) }, - ), - input: Inspect { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32) , () > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: simple_cluster :: * ; let CLUSTER_SELF_ID__free = hydro_lang :: location :: MemberId :: < () > :: from_tagless (({ __hydro_lang_cluster_self_id_1 / 3usize as u32 }) . clone ()) ; move | n | println ! ("cluster received: {:?} (self cluster id: {})" , n , CLUSTER_SELF_ID__free) }), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32)) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32) > (& res . unwrap ()) . unwrap () }, - ), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32)) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: simple_cluster :: * ; | (id , n) | (id . clone () , (id , n)) }), - input: CrossProduct { - left: FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , core :: option :: Option < hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > > > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: simple_cluster :: * ; | (i , e) | match e { MembershipEvent :: Joined => Some (i) , MembershipEvent :: Left => None , } }), - input: Cast { - inner: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () >, - }, - }, - }, - right: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Source { - source: Iter( - stageleft :: runtime_support :: type_hint :: < std :: ops :: Range < i32 > > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: simple_cluster :: * ; 0 .. 5 }), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: i32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: i32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32)), - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32)), - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, -] diff --git a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__partitioned_simple_cluster_ir@surface_graph_0.snap b/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__partitioned_simple_cluster_ir@surface_graph_0.snap deleted file mode 100644 index 89a8ef3..0000000 --- a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__partitioned_simple_cluster_ir@surface_graph_0.snap +++ /dev/null @@ -1,31 +0,0 @@ ---- -source: hydro_optimize/src/tests/mod.rs -expression: ir.surface_syntax_string() ---- -1v1 = source_stream ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: deploy :: deploy_runtime :: * ; let cluster_ids__free = __hydro_lang_cluster_ids_1 ; Box :: new (futures :: stream :: iter (cluster_ids__free . iter () . cloned () . map (| member_id | (member_id , MembershipEvent :: Joined)))) as Box < dyn futures :: Stream < Item = (TaglessMemberId , MembershipEvent) > + Unpin , > }); -2v1 = map (stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) })); -3v1 = filter_map (stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , core :: option :: Option < hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > > > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: simple_cluster :: * ; | (i , e) | match e { MembershipEvent :: Joined => Some (i) , MembershipEvent :: Left => None , } })); -4v1 = source_iter (stageleft :: runtime_support :: type_hint :: < std :: ops :: Range < i32 > > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: simple_cluster :: * ; 0 .. 5 })); -5v1 = map (| (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }); -6v1 = cross_join_multiset :: < 'static , 'static > (); -7v1 = multiset_delta (); -8v1 = map (stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32)) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: simple_cluster :: * ; | (id , n) | (id . clone () , (id , n)) })); -9v1 = map (:: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32)) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) })); -10v1 = dest_sink (DUMMY_SINK); -11v1 = source_stream (DUMMY_SOURCE); -12v1 = map (| res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32) > (& b) . unwrap ()) }); -13v1 = map (| (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b)); -14v1 = for_each (stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32)) , () > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: simple_cluster :: * ; | (id , d) | println ! ("node received: ({}, {:?})" , id , d) })); - -1v1 -> 2v1; -2v1 -> 3v1; -4v1 -> 5v1; -6v1 -> 7v1; -3v1 -> 6v1; -5v1 -> 6v1; -7v1 -> 8v1; -9v1 -> 10v1; -8v1 -> 9v1; -11v1 -> 12v1; -12v1 -> 13v1; -13v1 -> 14v1; diff --git a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__partitioned_simple_cluster_ir@surface_graph_1.snap b/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__partitioned_simple_cluster_ir@surface_graph_1.snap deleted file mode 100644 index 586ccda..0000000 --- a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__partitioned_simple_cluster_ir@surface_graph_1.snap +++ /dev/null @@ -1,14 +0,0 @@ ---- -source: hydro_optimize/src/tests/mod.rs -expression: ir.surface_syntax_string() ---- -1v1 = source_stream (DUMMY_SOURCE); -2v1 = map (| res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32) > (& res . unwrap ()) . unwrap () }); -3v1 = inspect (stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32) , () > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: simple_cluster :: * ; let CLUSTER_SELF_ID__free = hydro_lang :: location :: MemberId :: < () > :: from_tagless (({ __hydro_lang_cluster_self_id_1 / 3usize as u32 }) . clone ()) ; move | n | println ! ("cluster received: {:?} (self cluster id: {})" , n , CLUSTER_SELF_ID__free) })); -4v1 = map (:: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < () > , i32) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () })); -5v1 = dest_sink (DUMMY_SINK); - -1v1 -> 2v1; -2v1 -> 3v1; -4v1 -> 5v1; -3v1 -> 4v1; diff --git a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__two_pc__two_pc_partition_coordinator.snap b/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__two_pc__two_pc_partition_coordinator.snap deleted file mode 100644 index ac6d084..0000000 --- a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__two_pc__two_pc_partition_coordinator.snap +++ /dev/null @@ -1,18378 +0,0 @@ ---- -source: hydro_optimize/src/tests/two_pc.rs -expression: "&ir" ---- -[ - CycleSink { - ident: Ident { - sym: cycle_1, - }, - input: AntiJoin { - pos: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - neg: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, - CycleSink { - ident: Ident { - sym: cycle_2, - }, - input: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_2, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, - CycleSink { - ident: Ident { - sym: cycle_3, - }, - input: AntiJoin { - pos: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_3, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - neg: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_3, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, - CycleSink { - ident: Ident { - sym: cycle_4, - }, - input: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_4, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, - CycleSink { - ident: Ident { - sym: cycle_5, - }, - input: FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < u32 , core :: option :: Option < u32 > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; let num_clients_per_node__free = 100usize ; move | virtual_id | { if virtual_id < num_clients_per_node__free as u32 { Some (virtual_id + 1) } else { None } } }), - input: Tee { - inner: : ChainFirst { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_5, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - second: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , ()) , u32 > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Cast { - inner: SingletonSource { - value: { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; 0u32 }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < () , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | _u | () }), - input: Batch { - inner: Source { - source: Iter( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: tick :: * ; let e__free = { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; () } ; [e__free] }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Optional { - bound: Unbounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (u32 , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, - CycleSink { - ident: Ident { - sym: cycle_6, - }, - input: ReduceKeyed { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < std :: time :: Instant , std :: time :: Instant , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | curr_time , new_time | { if new_time > * curr_time { * curr_time = new_time ; } } }), - input: ObserveNonDet { - inner: Chain { - first: Chain { - first: Cast { - inner: Tee { - inner: : DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_6, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - second: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < u32 , (u32 , std :: time :: Instant) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | virtual_id | (virtual_id , Instant :: now ()) }), - input: Tee { - inner: : Cast { - inner: Tee { - inner: : ChainFirst { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_5, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - second: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , ()) , u32 > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Cast { - inner: SingletonSource { - value: { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; 0u32 }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < () , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | _u | () }), - input: Batch { - inner: Source { - source: Iter( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: tick :: * ; let e__free = { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; () } ; [e__free] }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Optional { - bound: Unbounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (u32 , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , std :: time :: Instant), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - second: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , core :: option :: Option < u32 >) , (u32 , std :: time :: Instant) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < core :: option :: Option < u32 > , std :: time :: Instant > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | _payload | Instant :: now () }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , (u32 , core :: option :: Option < u32 >) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < u32 , core :: option :: Option < u32 > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | payload | Some (payload) }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Batch { - inner: Cast { - inner: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (u32 , u32)) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: Cast { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_3, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, - CycleSink { - ident: Ident { - sym: cycle_0, - }, - input: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , core :: option :: Option < u32 >) , (u32 , u32) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: paxos_bench :: * ; move | (virtual_id , payload) | { let value = if let Some (payload) = payload { payload + 1 } else { 0 } ; (virtual_id , value) } }), - input: Cast { - inner: YieldConcat { - inner: Chain { - first: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < u32 , (u32 , core :: option :: Option < u32 >) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | virtual_id | (virtual_id , None) }), - input: Tee { - inner: : Cast { - inner: Tee { - inner: : ChainFirst { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_5, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - second: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , ()) , u32 > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Cast { - inner: SingletonSource { - value: { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; 0u32 }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < () , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | _u | () }), - input: Batch { - inner: Source { - source: Iter( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: tick :: * ; let e__free = { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; () } ; [e__free] }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Optional { - bound: Unbounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (u32 , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , core :: option :: Option < u32 >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - second: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , (u32 , core :: option :: Option < u32 >) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < u32 , core :: option :: Option < u32 > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | payload | Some (payload) }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Batch { - inner: Cast { - inner: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (u32 , u32)) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: Cast { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_3, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , core :: option :: Option < u32 >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, - ForEach { - f: stageleft :: runtime_support :: fn1_type_hint :: < usize , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | num_clients_not_responded | println ! ("Awaiting {} clients" , num_clients_not_responded) }), - input: ObserveNonDet { - inner: Cast { - inner: YieldConcat { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (usize , ()) , usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Batch { - inner: YieldConcat { - inner: Cast { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < (usize , usize) , core :: option :: Option < usize > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (num_clients , num_clients_with_throughput) | { if num_clients > num_clients_with_throughput { Some (num_clients - num_clients_with_throughput) } else { None } } }), - input: Cast { - inner: CrossSingleton { - left: Tee { - inner: : Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool) , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: membership :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: membership :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 3, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool), - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - right: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | throughputs | throughputs . sample_mean () > 0.0 }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: Tee { - inner: : ReduceKeyed { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | combined , new | { * combined = new ; } }), - input: ObserveNonDet { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > (& b) . unwrap ()) }, - ), - input: Cast { - inner: YieldConcat { - inner: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Batch { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (_ , stats) | stats }), - input: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | | (0 , { RollingAverage :: new () }) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , (usize , bool) , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (total , stats) , (batch_size , reset) | { if reset { if * total > 0 { stats . add_sample (* total as f64) ; } * total = 0 ; } else { * total += batch_size ; } } }), - input: Chain { - first: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < usize , (usize , bool) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | batch_size | (batch_size , false) }), - input: YieldConcat { - inner: Cast { - inner: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , core :: option :: Option < u32 > , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , core :: option :: Option < u32 >) , core :: option :: Option < u32 > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , (u32 , core :: option :: Option < u32 >) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < u32 , core :: option :: Option < u32 > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | payload | Some (payload) }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Batch { - inner: Cast { - inner: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (u32 , u32)) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: Cast { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_3, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , core :: option :: Option < u32 >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: core :: option :: Option < u32 >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - second: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , (usize , bool) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | _ | (0 , true) }), - input: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_secs (1) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Singleton { - bound: Unbounded, - element_type: (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Singleton { - bound: Unbounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | _u | () }), - input: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ , _ | { } }), - input: Batch { - inner: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: AtLeastOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 7, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _u | () }), - input: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ , _ | { } }), - input: Batch { - inner: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 7, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 7, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 7, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 7, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 7, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: usize, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, - ForEach { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , usize) , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; move | (throughputs , num_client_machines) | { if throughputs . sample_count () >= 2 { let mean = throughputs . sample_mean () * num_client_machines as f64 ; if let Some ((lower , upper)) = throughputs . confidence_interval_99 () { println ! ("Throughput: {:.2} - {:.2} - {:.2} requests/s" , lower * num_client_machines as f64 , mean , upper * num_client_machines as f64) ; } } } }), - input: ObserveNonDet { - inner: YieldConcat { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , usize) , ()) , (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , usize) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: CrossSingleton { - left: Batch { - inner: Cast { - inner: YieldConcat { - inner: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Batch { - inner: YieldConcat { - inner: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | combined , new | { combined . add (new) ; } }), - input: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (_ , v) | v }), - input: Batch { - inner: Tee { - inner: : ReduceKeyed { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | combined , new | { * combined = new ; } }), - input: ObserveNonDet { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > (& b) . unwrap ()) }, - ), - input: Cast { - inner: YieldConcat { - inner: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Batch { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (_ , stats) | stats }), - input: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | | (0 , { RollingAverage :: new () }) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , (usize , bool) , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (total , stats) , (batch_size , reset) | { if reset { if * total > 0 { stats . add_sample (* total as f64) ; } * total = 0 ; } else { * total += batch_size ; } } }), - input: Chain { - first: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < usize , (usize , bool) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | batch_size | (batch_size , false) }), - input: YieldConcat { - inner: Cast { - inner: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , core :: option :: Option < u32 > , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , core :: option :: Option < u32 >) , core :: option :: Option < u32 > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , (u32 , core :: option :: Option < u32 >) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < u32 , core :: option :: Option < u32 > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | payload | Some (payload) }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Batch { - inner: Cast { - inner: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (u32 , u32)) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: Cast { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_3, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , core :: option :: Option < u32 >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: core :: option :: Option < u32 >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - second: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , (usize , bool) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | _ | (0 , true) }), - input: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_secs (1) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Singleton { - bound: Unbounded, - element_type: (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Singleton { - bound: Unbounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | _u | () }), - input: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ , _ | { } }), - input: Batch { - inner: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: AtLeastOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 8, - Process( - 4, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 8, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 8, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 8, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Optional { - bound: Unbounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 9, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | _u | () }), - input: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ , _ | { } }), - input: Batch { - inner: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 9, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 9, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 9, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 9, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 9, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 9, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - right: Cast { - inner: Tee { - inner: : Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool) , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: membership :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: membership :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 3, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool), - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , usize), - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < core :: option :: Option < () > , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _u | () }), - input: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < core :: option :: Option < () > , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | o | o . is_none () }), - input: Cast { - inner: ChainFirst { - first: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < () , core :: option :: Option < () > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | v | Some (v) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < usize , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ | () }), - input: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < (usize , usize) , core :: option :: Option < usize > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (num_clients , num_clients_with_throughput) | { if num_clients > num_clients_with_throughput { Some (num_clients - num_clients_with_throughput) } else { None } } }), - input: Cast { - inner: CrossSingleton { - left: Tee { - inner: : Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool) , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: membership :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: membership :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 3, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool), - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - right: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | throughputs | throughputs . sample_mean () > 0.0 }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: Tee { - inner: : ReduceKeyed { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | combined , new | { * combined = new ; } }), - input: ObserveNonDet { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > (& b) . unwrap ()) }, - ), - input: Cast { - inner: YieldConcat { - inner: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Batch { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (_ , stats) | stats }), - input: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | | (0 , { RollingAverage :: new () }) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , (usize , bool) , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (total , stats) , (batch_size , reset) | { if reset { if * total > 0 { stats . add_sample (* total as f64) ; } * total = 0 ; } else { * total += batch_size ; } } }), - input: Chain { - first: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < usize , (usize , bool) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | batch_size | (batch_size , false) }), - input: YieldConcat { - inner: Cast { - inner: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , core :: option :: Option < u32 > , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , core :: option :: Option < u32 >) , core :: option :: Option < u32 > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , (u32 , core :: option :: Option < u32 >) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < u32 , core :: option :: Option < u32 > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | payload | Some (payload) }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Batch { - inner: Cast { - inner: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (u32 , u32)) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: Cast { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_3, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , core :: option :: Option < u32 >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: core :: option :: Option < u32 >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - second: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , (usize , bool) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | _ | (0 , true) }), - input: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_secs (1) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Singleton { - bound: Unbounded, - element_type: (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Singleton { - bound: Unbounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | _u | () }), - input: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ , _ | { } }), - input: Batch { - inner: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: AtLeastOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - second: Cast { - inner: SingletonSource { - value: :: std :: option :: Option :: None, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , usize) , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , usize), - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , usize), - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, - ForEach { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; move | latencies | { println ! ("Latency p50: {:.3} | p99 {:.3} | p999 {:.3} ms ({:} samples)" , Duration :: from_nanos (latencies . value_at_quantile (0.5)) . as_micros () as f64 / 1000.0 , Duration :: from_nanos (latencies . value_at_quantile (0.99)) . as_micros () as f64 / 1000.0 , Duration :: from_nanos (latencies . value_at_quantile (0.999)) . as_micros () as f64 / 1000.0 , latencies . len ()) ; } }), - input: ObserveNonDet { - inner: YieldConcat { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > , ()) , hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Batch { - inner: Cast { - inner: YieldConcat { - inner: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > , ()) , hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Batch { - inner: YieldConcat { - inner: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > , hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | combined , new | { combined . add (new) . unwrap () ; } }), - input: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >) , hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (_ , v) | v }), - input: Batch { - inner: ReduceKeyed { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > , hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | combined , new | { * combined = new ; } }), - input: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: SerializableHistogramWrapper) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: SerializableHistogramWrapper , hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | histogram | histogram . histogram . borrow () . clone () }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: SerializableHistogramWrapper , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: SerializableHistogramWrapper > (& b) . unwrap ()) }, - ), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: SerializableHistogramWrapper > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | latencies | { SerializableHistogramWrapper { histogram : latencies , } } }), - input: Cast { - inner: YieldConcat { - inner: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > > , ()) , std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Batch { - inner: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; move | | Rc :: new (RefCell :: new (Histogram :: < u64 > :: new (3) . unwrap ())) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > > , core :: time :: Duration , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; move | latencies , latency | { latencies . borrow_mut () . record (latency . as_nanos () as u64) . unwrap () ; } }), - input: ObserveNonDet { - inner: YieldConcat { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (std :: time :: Instant , std :: time :: Instant) , core :: time :: Duration > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (prev_time , curr_time) | curr_time . duration_since (prev_time) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , (std :: time :: Instant , std :: time :: Instant)) , (std :: time :: Instant , std :: time :: Instant) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Join { - left: Cast { - inner: Cast { - inner: Tee { - inner: : DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_6, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , std :: time :: Instant), - }, - }, - }, - right: Cast { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , core :: option :: Option < u32 >) , (u32 , std :: time :: Instant) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < core :: option :: Option < u32 > , std :: time :: Instant > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | _payload | Instant :: now () }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , (u32 , core :: option :: Option < u32 >) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < u32 , core :: option :: Option < u32 > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | payload | Some (payload) }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Batch { - inner: Cast { - inner: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (u32 , u32)) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: Cast { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_3, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , std :: time :: Instant), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , (std :: time :: Instant , std :: time :: Instant)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: (std :: time :: Instant , std :: time :: Instant), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , (std :: time :: Instant , std :: time :: Instant)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (std :: time :: Instant , std :: time :: Instant), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: core :: time :: Duration, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: core :: time :: Duration, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: core :: time :: Duration, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Singleton { - bound: Unbounded, - element_type: std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 10, - Cluster( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > >, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | _u | () }), - input: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ , _ | { } }), - input: Batch { - inner: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 10, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 10, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 10, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 10, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > > , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 10, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 10, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: SerializableHistogramWrapper, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: SerializableHistogramWrapper), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: AtLeastOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: SerializableHistogramWrapper, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: AtLeastOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 11, - Process( - 4, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 11, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 11, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 11, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Optional { - bound: Unbounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 12, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | _u | () }), - input: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ , _ | { } }), - input: Batch { - inner: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 12, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 12, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 12, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 12, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 12, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 12, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < core :: option :: Option < () > , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _u | () }), - input: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < core :: option :: Option < () > , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | o | o . is_none () }), - input: Cast { - inner: ChainFirst { - first: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < () , core :: option :: Option < () > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | v | Some (v) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < usize , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ | () }), - input: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < (usize , usize) , core :: option :: Option < usize > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (num_clients , num_clients_with_throughput) | { if num_clients > num_clients_with_throughput { Some (num_clients - num_clients_with_throughput) } else { None } } }), - input: Cast { - inner: CrossSingleton { - left: Tee { - inner: : Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool) , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: membership :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: membership :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 3, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool), - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - right: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | throughputs | throughputs . sample_mean () > 0.0 }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: Tee { - inner: : ReduceKeyed { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | combined , new | { * combined = new ; } }), - input: ObserveNonDet { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > (& b) . unwrap ()) }, - ), - input: Cast { - inner: YieldConcat { - inner: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Batch { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (_ , stats) | stats }), - input: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | | (0 , { RollingAverage :: new () }) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , (usize , bool) , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (total , stats) , (batch_size , reset) | { if reset { if * total > 0 { stats . add_sample (* total as f64) ; } * total = 0 ; } else { * total += batch_size ; } } }), - input: Chain { - first: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < usize , (usize , bool) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | batch_size | (batch_size , false) }), - input: YieldConcat { - inner: Cast { - inner: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , core :: option :: Option < u32 > , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , core :: option :: Option < u32 >) , core :: option :: Option < u32 > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , (u32 , core :: option :: Option < u32 >) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < u32 , core :: option :: Option < u32 > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | payload | Some (payload) }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Batch { - inner: Cast { - inner: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (u32 , u32)) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: Cast { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_3, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple . 1 , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: Map { - f: | (_sender_id , b) | b, - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: location :: MemberId :: < () > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: Map { - f: | struct_or_tuple | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: :: hydro_lang :: location :: MemberId < () >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Cluster( - 1, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , core :: option :: Option < u32 >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: core :: option :: Option < u32 >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - second: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , (usize , bool) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | _ | (0 , true) }), - input: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_secs (1) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Singleton { - bound: Unbounded, - element_type: (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Singleton { - bound: Unbounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | _u | () }), - input: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ , _ | { } }), - input: Batch { - inner: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: AtLeastOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - second: Cast { - inner: SingletonSource { - value: :: std :: option :: Option :: None, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 4, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Process( - 4, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, -] diff --git a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__two_pc__two_pc_partition_participant.snap b/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__two_pc__two_pc_partition_participant.snap deleted file mode 100644 index 1e0aa58..0000000 --- a/hydro_optimize/src/tests/snapshots/hydro_optimize__tests__two_pc__two_pc_partition_participant.snap +++ /dev/null @@ -1,18115 +0,0 @@ ---- -source: hydro_optimize/src/tests/two_pc.rs -expression: "&ir" ---- -[ - CycleSink { - ident: Ident { - sym: cycle_1, - }, - input: AntiJoin { - pos: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - neg: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, - CycleSink { - ident: Ident { - sym: cycle_2, - }, - input: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_2, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, - CycleSink { - ident: Ident { - sym: cycle_3, - }, - input: AntiJoin { - pos: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_3, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - neg: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_3, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, - CycleSink { - ident: Ident { - sym: cycle_4, - }, - input: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_4, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, - CycleSink { - ident: Ident { - sym: cycle_5, - }, - input: FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < u32 , core :: option :: Option < u32 > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; let num_clients_per_node__free = 100usize ; move | virtual_id | { if virtual_id < num_clients_per_node__free as u32 { Some (virtual_id + 1) } else { None } } }), - input: Tee { - inner: : ChainFirst { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_5, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - second: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , ()) , u32 > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Cast { - inner: SingletonSource { - value: { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; 0u32 }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < () , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | _u | () }), - input: Batch { - inner: Source { - source: Iter( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: tick :: * ; let e__free = { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; () } ; [e__free] }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Optional { - bound: Unbounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (u32 , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, - CycleSink { - ident: Ident { - sym: cycle_6, - }, - input: ReduceKeyed { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < std :: time :: Instant , std :: time :: Instant , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | curr_time , new_time | { if new_time > * curr_time { * curr_time = new_time ; } } }), - input: ObserveNonDet { - inner: Chain { - first: Chain { - first: Cast { - inner: Tee { - inner: : DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_6, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - second: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < u32 , (u32 , std :: time :: Instant) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | virtual_id | (virtual_id , Instant :: now ()) }), - input: Tee { - inner: : Cast { - inner: Tee { - inner: : ChainFirst { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_5, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - second: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , ()) , u32 > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Cast { - inner: SingletonSource { - value: { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; 0u32 }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < () , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | _u | () }), - input: Batch { - inner: Source { - source: Iter( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: tick :: * ; let e__free = { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; () } ; [e__free] }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Optional { - bound: Unbounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (u32 , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , std :: time :: Instant), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - second: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , core :: option :: Option < u32 >) , (u32 , std :: time :: Instant) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < core :: option :: Option < u32 > , std :: time :: Instant > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | _payload | Instant :: now () }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , (u32 , core :: option :: Option < u32 >) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < u32 , core :: option :: Option < u32 > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | payload | Some (payload) }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Batch { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (u32 , u32)) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& res . unwrap ()) . unwrap () }, - ), - input: Cast { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_3, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, - CycleSink { - ident: Ident { - sym: cycle_0, - }, - input: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , core :: option :: Option < u32 >) , (u32 , u32) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: paxos_bench :: * ; move | (virtual_id , payload) | { let value = if let Some (payload) = payload { payload + 1 } else { 0 } ; (virtual_id , value) } }), - input: Cast { - inner: YieldConcat { - inner: Chain { - first: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < u32 , (u32 , core :: option :: Option < u32 >) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | virtual_id | (virtual_id , None) }), - input: Tee { - inner: : Cast { - inner: Tee { - inner: : ChainFirst { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_5, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - second: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , ()) , u32 > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Cast { - inner: SingletonSource { - value: { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; 0u32 }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < () , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | _u | () }), - input: Batch { - inner: Source { - source: Iter( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: tick :: * ; let e__free = { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; () } ; [e__free] }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Optional { - bound: Unbounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (u32 , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , core :: option :: Option < u32 >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - second: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , (u32 , core :: option :: Option < u32 >) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < u32 , core :: option :: Option < u32 > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | payload | Some (payload) }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Batch { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (u32 , u32)) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& res . unwrap ()) . unwrap () }, - ), - input: Cast { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_3, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , core :: option :: Option < u32 >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, - ForEach { - f: stageleft :: runtime_support :: fn1_type_hint :: < usize , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | num_clients_not_responded | println ! ("Awaiting {} clients" , num_clients_not_responded) }), - input: ObserveNonDet { - inner: Cast { - inner: YieldConcat { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (usize , ()) , usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Batch { - inner: YieldConcat { - inner: Cast { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < (usize , usize) , core :: option :: Option < usize > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (num_clients , num_clients_with_throughput) | { if num_clients > num_clients_with_throughput { Some (num_clients - num_clients_with_throughput) } else { None } } }), - input: Cast { - inner: CrossSingleton { - left: Tee { - inner: : Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool) , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: membership :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: membership :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool), - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - right: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | throughputs | throughputs . sample_mean () > 0.0 }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: Tee { - inner: : ReduceKeyed { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | combined , new | { * combined = new ; } }), - input: ObserveNonDet { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > (& b) . unwrap ()) }, - ), - input: Cast { - inner: YieldConcat { - inner: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Batch { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (_ , stats) | stats }), - input: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | | (0 , { RollingAverage :: new () }) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , (usize , bool) , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (total , stats) , (batch_size , reset) | { if reset { if * total > 0 { stats . add_sample (* total as f64) ; } * total = 0 ; } else { * total += batch_size ; } } }), - input: Chain { - first: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < usize , (usize , bool) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | batch_size | (batch_size , false) }), - input: YieldConcat { - inner: Cast { - inner: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , core :: option :: Option < u32 > , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , core :: option :: Option < u32 >) , core :: option :: Option < u32 > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , (u32 , core :: option :: Option < u32 >) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < u32 , core :: option :: Option < u32 > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | payload | Some (payload) }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Batch { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (u32 , u32)) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& res . unwrap ()) . unwrap () }, - ), - input: Cast { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_3, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , core :: option :: Option < u32 >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: core :: option :: Option < u32 >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - second: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , (usize , bool) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | _ | (0 , true) }), - input: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_secs (1) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Singleton { - bound: Unbounded, - element_type: (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Singleton { - bound: Unbounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | _u | () }), - input: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ , _ | { } }), - input: Batch { - inner: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: AtLeastOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 7, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _u | () }), - input: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ , _ | { } }), - input: Batch { - inner: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 7, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 7, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 7, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 7, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 7, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: usize, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, - ForEach { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , usize) , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; move | (throughputs , num_client_machines) | { if throughputs . sample_count () >= 2 { let mean = throughputs . sample_mean () * num_client_machines as f64 ; if let Some ((lower , upper)) = throughputs . confidence_interval_99 () { println ! ("Throughput: {:.2} - {:.2} - {:.2} requests/s" , lower * num_client_machines as f64 , mean , upper * num_client_machines as f64) ; } } } }), - input: ObserveNonDet { - inner: YieldConcat { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , usize) , ()) , (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , usize) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: CrossSingleton { - left: Batch { - inner: Cast { - inner: YieldConcat { - inner: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Batch { - inner: YieldConcat { - inner: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | combined , new | { combined . add (new) ; } }), - input: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (_ , v) | v }), - input: Batch { - inner: Tee { - inner: : ReduceKeyed { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | combined , new | { * combined = new ; } }), - input: ObserveNonDet { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > (& b) . unwrap ()) }, - ), - input: Cast { - inner: YieldConcat { - inner: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Batch { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (_ , stats) | stats }), - input: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | | (0 , { RollingAverage :: new () }) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , (usize , bool) , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (total , stats) , (batch_size , reset) | { if reset { if * total > 0 { stats . add_sample (* total as f64) ; } * total = 0 ; } else { * total += batch_size ; } } }), - input: Chain { - first: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < usize , (usize , bool) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | batch_size | (batch_size , false) }), - input: YieldConcat { - inner: Cast { - inner: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , core :: option :: Option < u32 > , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , core :: option :: Option < u32 >) , core :: option :: Option < u32 > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , (u32 , core :: option :: Option < u32 >) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < u32 , core :: option :: Option < u32 > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | payload | Some (payload) }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Batch { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (u32 , u32)) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& res . unwrap ()) . unwrap () }, - ), - input: Cast { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_3, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , core :: option :: Option < u32 >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: core :: option :: Option < u32 >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - second: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , (usize , bool) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | _ | (0 , true) }), - input: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_secs (1) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Singleton { - bound: Unbounded, - element_type: (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Singleton { - bound: Unbounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | _u | () }), - input: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ , _ | { } }), - input: Batch { - inner: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: AtLeastOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 8, - Process( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 8, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 8, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 8, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Optional { - bound: Unbounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 9, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | _u | () }), - input: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ , _ | { } }), - input: Batch { - inner: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 9, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 9, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 9, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 9, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 9, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 9, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - right: Cast { - inner: Tee { - inner: : Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool) , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: membership :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: membership :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool), - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , usize), - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < core :: option :: Option < () > , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _u | () }), - input: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < core :: option :: Option < () > , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | o | o . is_none () }), - input: Cast { - inner: ChainFirst { - first: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < () , core :: option :: Option < () > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | v | Some (v) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < usize , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ | () }), - input: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < (usize , usize) , core :: option :: Option < usize > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (num_clients , num_clients_with_throughput) | { if num_clients > num_clients_with_throughput { Some (num_clients - num_clients_with_throughput) } else { None } } }), - input: Cast { - inner: CrossSingleton { - left: Tee { - inner: : Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool) , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: membership :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: membership :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool), - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - right: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | throughputs | throughputs . sample_mean () > 0.0 }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: Tee { - inner: : ReduceKeyed { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | combined , new | { * combined = new ; } }), - input: ObserveNonDet { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > (& b) . unwrap ()) }, - ), - input: Cast { - inner: YieldConcat { - inner: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Batch { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (_ , stats) | stats }), - input: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | | (0 , { RollingAverage :: new () }) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , (usize , bool) , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (total , stats) , (batch_size , reset) | { if reset { if * total > 0 { stats . add_sample (* total as f64) ; } * total = 0 ; } else { * total += batch_size ; } } }), - input: Chain { - first: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < usize , (usize , bool) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | batch_size | (batch_size , false) }), - input: YieldConcat { - inner: Cast { - inner: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , core :: option :: Option < u32 > , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , core :: option :: Option < u32 >) , core :: option :: Option < u32 > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , (u32 , core :: option :: Option < u32 >) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < u32 , core :: option :: Option < u32 > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | payload | Some (payload) }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Batch { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (u32 , u32)) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& res . unwrap ()) . unwrap () }, - ), - input: Cast { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_3, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , core :: option :: Option < u32 >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: core :: option :: Option < u32 >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - second: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , (usize , bool) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | _ | (0 , true) }), - input: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_secs (1) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Singleton { - bound: Unbounded, - element_type: (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Singleton { - bound: Unbounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | _u | () }), - input: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ , _ | { } }), - input: Batch { - inner: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: AtLeastOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - second: Cast { - inner: SingletonSource { - value: :: std :: option :: Option :: None, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , usize) , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , usize), - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , usize), - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, - ForEach { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; move | latencies | { println ! ("Latency p50: {:.3} | p99 {:.3} | p999 {:.3} ms ({:} samples)" , Duration :: from_nanos (latencies . value_at_quantile (0.5)) . as_micros () as f64 / 1000.0 , Duration :: from_nanos (latencies . value_at_quantile (0.99)) . as_micros () as f64 / 1000.0 , Duration :: from_nanos (latencies . value_at_quantile (0.999)) . as_micros () as f64 / 1000.0 , latencies . len ()) ; } }), - input: ObserveNonDet { - inner: YieldConcat { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > , ()) , hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Batch { - inner: Cast { - inner: YieldConcat { - inner: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > , ()) , hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Batch { - inner: YieldConcat { - inner: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > , hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | combined , new | { combined . add (new) . unwrap () ; } }), - input: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >) , hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (_ , v) | v }), - input: Batch { - inner: ReduceKeyed { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > , hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | combined , new | { * combined = new ; } }), - input: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: SerializableHistogramWrapper) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: SerializableHistogramWrapper , hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | histogram | histogram . histogram . borrow () . clone () }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: SerializableHistogramWrapper , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: SerializableHistogramWrapper > (& b) . unwrap ()) }, - ), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: SerializableHistogramWrapper > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | latencies | { SerializableHistogramWrapper { histogram : latencies , } } }), - input: Cast { - inner: YieldConcat { - inner: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > > , ()) , std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Batch { - inner: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; move | | Rc :: new (RefCell :: new (Histogram :: < u64 > :: new (3) . unwrap ())) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > > , core :: time :: Duration , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; move | latencies , latency | { latencies . borrow_mut () . record (latency . as_nanos () as u64) . unwrap () ; } }), - input: ObserveNonDet { - inner: YieldConcat { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (std :: time :: Instant , std :: time :: Instant) , core :: time :: Duration > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (prev_time , curr_time) | curr_time . duration_since (prev_time) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , (std :: time :: Instant , std :: time :: Instant)) , (std :: time :: Instant , std :: time :: Instant) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Join { - left: Cast { - inner: Cast { - inner: Tee { - inner: : DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_6, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , std :: time :: Instant), - }, - }, - }, - right: Cast { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , core :: option :: Option < u32 >) , (u32 , std :: time :: Instant) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < core :: option :: Option < u32 > , std :: time :: Instant > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | _payload | Instant :: now () }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , (u32 , core :: option :: Option < u32 >) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < u32 , core :: option :: Option < u32 > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | payload | Some (payload) }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Batch { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (u32 , u32)) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& res . unwrap ()) . unwrap () }, - ), - input: Cast { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_3, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: std :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , std :: time :: Instant), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , (std :: time :: Instant , std :: time :: Instant)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: (std :: time :: Instant , std :: time :: Instant), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , (std :: time :: Instant , std :: time :: Instant)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (std :: time :: Instant , std :: time :: Instant), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: core :: time :: Duration, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: core :: time :: Duration, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: core :: time :: Duration, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Singleton { - bound: Unbounded, - element_type: std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 10, - Cluster( - 2, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > >, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | _u | () }), - input: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ , _ | { } }), - input: Batch { - inner: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 10, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 10, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 10, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 10, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > > , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 10, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 10, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: std :: rc :: Rc < core :: cell :: RefCell < hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > > >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: SerializableHistogramWrapper, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: SerializableHistogramWrapper), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: AtLeastOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: SerializableHistogramWrapper, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: AtLeastOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 11, - Process( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 11, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 11, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 11, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Optional { - bound: Unbounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 12, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | _u | () }), - input: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ , _ | { } }), - input: Batch { - inner: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 12, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 12, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 12, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 12, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 12, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 12, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < core :: option :: Option < () > , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _u | () }), - input: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < core :: option :: Option < () > , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | o | o . is_none () }), - input: Cast { - inner: ChainFirst { - first: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < () , core :: option :: Option < () > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: optional :: * ; | v | Some (v) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < usize , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ | () }), - input: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < (usize , usize) , core :: option :: Option < usize > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (num_clients , num_clients_with_throughput) | { if num_clients > num_clients_with_throughput { Some (num_clients - num_clients_with_throughput) } else { None } } }), - input: Cast { - inner: CrossSingleton { - left: Tee { - inner: : Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool) , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: membership :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: membership :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 2, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool), - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - right: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , bool > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | throughputs | throughputs . sample_mean () > 0.0 }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: Tee { - inner: : ReduceKeyed { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | combined , new | { * combined = new ; } }), - input: ObserveNonDet { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > (& b) . unwrap ()) }, - ), - input: Cast { - inner: YieldConcat { - inner: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | (d , _signal) | d }), - input: CrossSingleton { - left: Batch { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (_ , stats) | stats }), - input: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | | (0 , { RollingAverage :: new () }) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage) , (usize , bool) , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | (total , stats) , (batch_size , reset) | { if reset { if * total > 0 { stats . add_sample (* total as f64) ; } * total = 0 ; } else { * total += batch_size ; } } }), - input: Chain { - first: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < usize , (usize , bool) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | batch_size | (batch_size , false) }), - input: YieldConcat { - inner: Cast { - inner: Fold { - init: stageleft :: runtime_support :: fn0_type_hint :: < usize > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | | 0usize }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < usize , core :: option :: Option < u32 > , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | count , _ | * count += 1 }), - input: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , core :: option :: Option < u32 >) , core :: option :: Option < u32 > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , (u32 , core :: option :: Option < u32 >) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; let f__free = stageleft :: runtime_support :: fn1_type_hint :: < u32 , core :: option :: Option < u32 > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | payload | Some (payload) }) ; { let orig = f__free ; move | (k , v) | (k , orig (v)) } }), - input: Batch { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (u32 , u32)) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& res . unwrap ()) . unwrap () }, - ), - input: Cast { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_3, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: YieldConcat { - inner: Tee { - inner: : FilterMap { - f: stageleft :: runtime_support :: fn1_type_hint :: < ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)) , core :: option :: Option < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; let min__free = 3usize ; move | (key , (success , _error)) | if success >= min__free { Some (key) } else { None } }), - input: Cast { - inner: Cast { - inner: Tee { - inner: : FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < (usize , usize) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | | (0 , 0) }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < (usize , usize) , core :: result :: Result < () , () > , () > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: quorum :: * ; move | accum , value | { if value . is_ok () { accum . 0 += 1 ; } else { accum . 1 += 1 ; } } }), - input: ObserveNonDet { - inner: Cast { - inner: Tee { - inner: : Chain { - first: DeferTick { - input: CycleSource { - ident: Ident { - sym: cycle_1, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - second: Batch { - inner: Tee { - inner: : Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >) > ({ use hydro_test :: __staged :: __deps :: * ; use hydro_test :: __staged :: cluster :: two_pc :: * ; | kv | (kv , Ok :: < () , () > (())) }), - input: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_stream :: * ; | (_ , v) | v }), - input: Cast { - inner: Cast { - inner: Map { - f: | (sender_id , b) | (:: hydro_lang :: location :: MemberId :: < _ > :: from_raw_id (sender_id . raw_id / 3usize as u32) , b), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc :: Participant > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& b) . unwrap ()) }, - ), - input: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_lang :: __staged :: location :: MemberId < _ > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))) , _ > (| (id , data) | { (id . into_tagless () , hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into ()) }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { hydro_lang :: runtime_support :: bincode :: deserialize :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) > (& res . unwrap ()) . unwrap () }, - ), - input: Map { - f: | (orig_dest , struct_or_tuple) : (:: hydro_lang :: location :: MemberId < _ > , _) | { let mut s = :: std :: hash :: DefaultHasher :: new () ; :: std :: hash :: Hash :: hash (& struct_or_tuple , & mut s) ; let partition_val = :: std :: hash :: Hasher :: finish (& s) as u32 ; (:: hydro_lang :: location :: MemberId :: < () > :: from_raw_id ((orig_dest . raw_id * 3usize as u32) + (partition_val % 3usize as u32) as u32) , struct_or_tuple) }, - input: YieldConcat { - inner: Cast { - inner: CrossProduct { - left: ObserveNonDet { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; | (k , _) | k }), - input: Cast { - inner: Cast { - inner: Filter { - f: stageleft :: runtime_support :: fn1_borrow_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool) , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: keyed_singleton :: * ; let f__free = stageleft :: runtime_support :: fn1_borrow_type_hint :: < bool , bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | b | * b }) ; { let orig = f__free ; move | t : & (_ , _) | orig (& t . 1) } }), - input: Batch { - inner: FoldKeyed { - init: stageleft :: runtime_support :: fn0_type_hint :: < bool > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | | false }), - acc: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < bool , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: networking :: * ; | present , event | { match event { MembershipEvent :: Joined => * present = true , MembershipEvent :: Left => * present = false , } } }), - input: Cast { - inner: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent) > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; | (k , v) | (MemberId :: from_tagless (k) , v) }), - input: Source { - source: ClusterMembers( - Cluster( - 1, - ), - ), - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: TaglessMemberId , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: MembershipEvent, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: bool, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - }, - }, - }, - right: Batch { - inner: Cast { - inner: Cast { - inner: Network { - serialize_fn: Some( - :: hydro_lang :: runtime_support :: stageleft :: runtime_support :: fn1_type_hint :: < (u32 , u32) , _ > (| data | { hydro_lang :: runtime_support :: bincode :: serialize (& data) . unwrap () . into () }), - ), - instantiate_fn: , - deserialize_fn: Some( - | res | { let (id , b) = res . unwrap () ; (hydro_lang :: __staged :: location :: MemberId :: < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > :: from_tagless (id as hydro_lang :: __staged :: location :: TaglessMemberId) , hydro_lang :: runtime_support :: bincode :: deserialize :: < (u32 , u32) > (& b) . unwrap ()) }, - ), - input: CycleSource { - ident: Ident { - sym: cycle_0, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 0, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 1, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 2, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 1, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant >, - value_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc :: Participant > , (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32))), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , core :: result :: Result < () , () >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: core :: result :: Result < () , () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - value_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: ((hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)) , (usize , usize)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 3, - Process( - 0, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , (u32 , u32)), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 0, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , u32), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: u32, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: NoOrder, - value_retry: ExactlyOnce, - key_type: u32, - value_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (u32 , core :: option :: Option < u32 >), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: core :: option :: Option < u32 >, - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: core :: option :: Option < u32 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 4, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - second: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , (usize , bool) > ({ use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; | _ | (0 , true) }), - input: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_secs (1) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (usize , bool), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Singleton { - bound: Unbounded, - element_type: (usize , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Singleton { - bound: Unbounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - right: Map { - f: stageleft :: runtime_support :: fn1_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: singleton :: * ; | _u | () }), - input: Reduce { - f: stageleft :: runtime_support :: fn2_borrow_mut_type_hint :: < hydro_test :: __staged :: __deps :: tokio :: time :: Instant , hydro_test :: __staged :: __deps :: tokio :: time :: Instant , () > ({ use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: live_collections :: stream :: * ; | _ , _ | { } }), - input: Batch { - inner: Source { - source: Stream( - { use hydro_lang :: __staged :: __deps :: * ; use hydro_lang :: __staged :: location :: * ; let interval__free = { use hydro_std :: __staged :: __deps :: * ; use hydro_std :: __staged :: bench_client :: * ; Duration :: from_millis (1000) } ; tokio_stream :: wrappers :: IntervalStream :: new (tokio :: time :: interval (interval__free)) }, - ), - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: tokio :: time :: Instant, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 6, - Cluster( - 2, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Cluster( - 2, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: AtLeastOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedStream { - bound: Unbounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: KeyedSingleton { - bound: Unbounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedSingleton { - bound: Bounded, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: KeyedStream { - bound: Bounded, - value_order: TotalOrder, - value_retry: ExactlyOnce, - key_type: hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client >, - value_type: hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: NoOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - trusted: true, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_lang :: location :: member_id :: MemberId < hydro_test :: __staged :: cluster :: two_pc_bench :: Client > , hydro_test :: __staged :: __deps :: hydro_std :: bench_client :: rolling_average :: RollingAverage), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: (usize , usize), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: usize, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - second: Cast { - inner: SingletonSource { - value: :: std :: option :: Option :: None, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Singleton { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: core :: option :: Option < () >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Optional { - bound: Bounded, - element_type: (), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: (hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 > , ()), - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Tick( - 5, - Process( - 3, - ), - ), - collection_kind: Stream { - bound: Bounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: AtLeastOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - trusted: false, - metadata: HydroIrMetadata { - location_id: Process( - 3, - ), - collection_kind: Stream { - bound: Unbounded, - order: TotalOrder, - retry: ExactlyOnce, - element_type: hydro_test :: __staged :: __deps :: hydro_std :: __staged :: __deps :: hdrhistogram :: Histogram < u64 >, - }, - }, - }, - op_metadata: HydroIrOpMetadata, - }, -] diff --git a/hydro_optimize/src/tests/two_pc.rs b/hydro_optimize/src/tests/two_pc.rs deleted file mode 100644 index ce1fd12..0000000 --- a/hydro_optimize/src/tests/two_pc.rs +++ /dev/null @@ -1,138 +0,0 @@ -use std::collections::{BTreeMap, HashMap}; - -use hydro_build_utils::insta; -use hydro_lang::compile::ir::deep_clone; -use hydro_lang::deploy::HydroDeploy; -use hydro_lang::location::Location; -use hydro_lang::prelude::*; -use hydro_test::cluster::two_pc::{Coordinator, Participant}; -use hydro_test::cluster::two_pc_bench::{Aggregator, Client}; - -use crate::debug::name_to_id_map; -use crate::partition_node_analysis::{nodes_to_partition, partitioning_analysis}; -use crate::partitioner::{Partitioner, partition}; -use crate::repair::{cycle_source_to_sink_input, inject_id, inject_location}; - -const NUM_PARTICIPANTS: usize = 3; - -fn create_two_pc<'a>( - coordinator: &Process<'a, Coordinator>, - participants: &Cluster<'a, Participant>, - clients: &Cluster<'a, Client>, - client_aggregator: &Process<'a, Aggregator>, -) { - hydro_test::cluster::two_pc_bench::two_pc_bench( - 100, - coordinator, - participants, - NUM_PARTICIPANTS, - clients, - client_aggregator, - ); -} - -#[test] -fn two_pc_partition_coordinator() { - let mut builder = FlowBuilder::new(); - let coordinator = builder.process(); - let partitioned_coordinator = builder.cluster::<()>(); - let participants = builder.cluster(); - let clients = builder.cluster(); - let client_aggregator = builder.process(); - - create_two_pc(&coordinator, &participants, &clients, &client_aggregator); - - let mut cycle_data = HashMap::new(); - let built = builder - .optimize_with(|ir| { - inject_id(ir); - cycle_data = cycle_source_to_sink_input(ir); - inject_location(ir, &cycle_data); - }) - .into_deploy::(); - let mut ir = deep_clone(built.ir()); - - // Coordinator - let coordinator_partitioning = partitioning_analysis(&mut ir, &coordinator.id(), &cycle_data); - let name_to_id = name_to_id_map(&mut ir); - let c_prepare_id = *name_to_id.get("c_prepare").unwrap(); - let c_votes_id = *name_to_id.get("c_votes").unwrap(); - let c_commits_id = *name_to_id.get("c_commits").unwrap(); - // 1 is the partitioning index of those inputs. Specifically, given the client sends (sender_id, payload) to the coordinator, we can partition on the entire payload - let expected_coordinator_partitioning = vec![BTreeMap::from([ - (c_votes_id - 1, vec!["1".to_string()]), - (c_commits_id - 1, vec!["1".to_string()]), - ])]; - let expected_coordinator_input_parents = BTreeMap::from([ - (c_prepare_id - 2, c_prepare_id - 3), - (c_votes_id - 1, c_votes_id - 2), - (c_commits_id - 1, c_commits_id - 2), - ]); - assert_eq!( - coordinator_partitioning, - Some(( - expected_coordinator_partitioning, - expected_coordinator_input_parents - )) - ); - let coordinator_nodes_to_partition = nodes_to_partition(coordinator_partitioning).unwrap(); - let coordinator_partitioner = Partitioner { - nodes_to_partition: coordinator_nodes_to_partition, - num_partitions: 3, - location_id: coordinator.id().key(), - new_cluster_id: Some(partitioned_coordinator.id().key()), - }; - partition(&mut ir, &coordinator_partitioner); - - insta::assert_debug_snapshot!(&ir); -} - -#[test] -fn two_pc_partition_participant() { - let mut builder = FlowBuilder::new(); - let coordinator = builder.process(); - let participants = builder.cluster(); - let clients = builder.cluster(); - let client_aggregator = builder.process(); - - create_two_pc(&coordinator, &participants, &clients, &client_aggregator); - - let mut cycle_data = HashMap::new(); - let built = builder - .optimize_with(|ir| { - inject_id(ir); - cycle_data = cycle_source_to_sink_input(ir); - inject_location(ir, &cycle_data); - }) - .into_deploy::(); - let mut ir = deep_clone(built.ir()); - - let participant_partitioning = partitioning_analysis(&mut ir, &participants.id(), &cycle_data); - // Recalculate node IDs since they've changed as well - let name_to_id = name_to_id_map(&mut ir); - let p_prepare_id = *name_to_id.get("p_prepare").unwrap(); - let p_commits_id = *name_to_id.get("p_commits").unwrap(); - // Participants can partition on ANYTHING, since they only execute maps - let expected_participant_partitionings = vec![]; - let expected_participant_input_parents = BTreeMap::from([ - (p_prepare_id, p_prepare_id - 1), - (p_commits_id, p_commits_id - 1), - ]); - assert_eq!( - participant_partitioning, - Some(( - expected_participant_partitionings, - expected_participant_input_parents - )) - ); - let participant_nodes_to_partition = nodes_to_partition(participant_partitioning).unwrap(); - let participant_partitioner = Partitioner { - nodes_to_partition: participant_nodes_to_partition, - num_partitions: 3, - location_id: participants.id().key(), - new_cluster_id: None, - }; - partition(&mut ir, &participant_partitioner); - - insta::assert_debug_snapshot!(&ir); -} diff --git a/hydro_optimize_examples/examples/network_calibrator.rs b/hydro_optimize_examples/examples/network_calibrator.rs index 17cee8e..db6a002 100644 --- a/hydro_optimize_examples/examples/network_calibrator.rs +++ b/hydro_optimize_examples/examples/network_calibrator.rs @@ -45,6 +45,7 @@ async fn main() { let num_clients_per_node = 1000; let message_sizes = vec![1, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192]; let num_seconds_to_profile = Some(60); + let interval_millis = 1000; for message_size in message_sizes { let mut builder = FlowBuilder::new(); @@ -62,6 +63,7 @@ async fn main() { &server, &clients, &client_aggregator, + interval_millis, ); deploy_and_optimize( diff --git a/hydro_optimize_examples/examples/partition_two_pc.rs b/hydro_optimize_examples/examples/partition_two_pc.rs index bea9959..243db19 100644 --- a/hydro_optimize_examples/examples/partition_two_pc.rs +++ b/hydro_optimize_examples/examples/partition_two_pc.rs @@ -6,6 +6,7 @@ use hydro_optimize::deploy::{HostType, ReusableHosts}; use hydro_optimize::deploy_and_analyze::{ Optimizations, ReusableClusters, ReusableProcesses, deploy_and_optimize, }; +use hydro_optimize::parse_results::print_parseable_bench_results; use hydro_test::cluster::two_pc_bench::{Aggregator, Client}; #[derive(Parser, Debug)] diff --git a/hydro_optimize_examples/examples/perf_paxos.rs b/hydro_optimize_examples/examples/perf_paxos.rs index e40e93d..bfcc42b 100644 --- a/hydro_optimize_examples/examples/perf_paxos.rs +++ b/hydro_optimize_examples/examples/perf_paxos.rs @@ -5,7 +5,7 @@ use hydro_optimize::deploy::{HostType, ReusableHosts}; use hydro_optimize::deploy_and_analyze::{ Optimizations, ReusableClusters, ReusableProcesses, deploy_and_optimize, }; -use hydro_optimize::parse_results::print_parseable_bench_results; +use hydro_std::bench_client::pretty_print_bench_results; use hydro_test::cluster::paxos::{CorePaxos, PaxosConfig}; use hydro_test::cluster::paxos_bench::{Aggregator, Client}; @@ -76,7 +76,7 @@ async fn main() { &client_aggregator, &replicas, print_result_frequency, - print_parseable_bench_results, + pretty_print_bench_results, // Note: Throughput/latency numbers won't be accessible to deploy_and_optimize ); // Deploy From 593299c9d4c5381686464c9a7bcc68edf10ff685 Mon Sep 17 00:00:00 2001 From: David Chu Date: Tue, 3 Feb 2026 23:38:52 +0000 Subject: [PATCH 31/35] FlowBuilder fix --- hydro_optimize/src/deploy_and_analyze.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hydro_optimize/src/deploy_and_analyze.rs b/hydro_optimize/src/deploy_and_analyze.rs index dabf7f1..3b67f49 100644 --- a/hydro_optimize/src/deploy_and_analyze.rs +++ b/hydro_optimize/src/deploy_and_analyze.rs @@ -379,7 +379,6 @@ pub async fn deploy_and_optimize<'a>( decoupled_location: new_cluster.id().clone(), }; decoupler::decouple(&mut ir, &decouple_with_location); - post_rewrite_builder.replace_ir(ir); clusters.named_clusters.push(( new_cluster.id().key(), format!("{}-decouple-{}", bottleneck_name, iteration), @@ -388,6 +387,7 @@ pub async fn deploy_and_optimize<'a>( // TODO: Save decoupling decision to file } + post_rewrite_builder.replace_ir(ir); builder = post_rewrite_builder.finalize(); } From e03b88d07f592e5c7f5c2db0d7c7afb487ed1c3a Mon Sep 17 00:00:00 2001 From: David Chu Date: Wed, 4 Feb 2026 18:50:49 +0000 Subject: [PATCH 32/35] Move hydro_optimize back into dev dependencies to reduce binary size --- Cargo.lock | 2 +- hydro_optimize/Cargo.toml | 1 - hydro_optimize/src/deploy.rs | 6 +- hydro_optimize/src/deploy_and_analyze.rs | 2 +- hydro_optimize/src/lib.rs | 13 +--- hydro_optimize/src/parse_results.rs | 51 --------------- hydro_optimize_examples/Cargo.toml | 3 +- .../examples/benchmark_paxos.rs | 2 +- hydro_optimize_examples/src/lib.rs | 64 ++++++++++++++++--- .../src/network_calibrator.rs | 3 +- .../src/simple_kv_bench.rs | 3 +- 11 files changed, 71 insertions(+), 79 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 1dc9717..fd4e980 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2060,7 +2060,6 @@ dependencies = [ "clap", "ctor 0.2.9", "good_lp", - "hdrhistogram", "hydro_build_utils", "hydro_deploy", "hydro_lang", @@ -2085,6 +2084,7 @@ dependencies = [ "clap", "ctor 0.2.9", "dfir_lang", + "hdrhistogram", "hydro_build_utils", "hydro_deploy", "hydro_lang", diff --git a/hydro_optimize/Cargo.toml b/hydro_optimize/Cargo.toml index 54bcbe4..042662e 100644 --- a/hydro_optimize/Cargo.toml +++ b/hydro_optimize/Cargo.toml @@ -11,7 +11,6 @@ all-features = true [dependencies] good_lp = { version = "1.14.0", features = ["highs"], default-features = false } -hdrhistogram = "7.5.4" hydro_deploy.workspace = true hydro_lang = { workspace = true, features = ["deploy"] } hydro_std.workspace = true diff --git a/hydro_optimize/src/deploy.rs b/hydro_optimize/src/deploy.rs index 3c5ab12..77666a7 100644 --- a/hydro_optimize/src/deploy.rs +++ b/hydro_optimize/src/deploy.rs @@ -33,8 +33,8 @@ pub struct ReusableHosts { } // Note: Aws AMIs vary by region. If you are changing the region, please also change the AMI. -const AWS_REGION: &str = "us-east-1"; -const AWS_INSTANCE_AMI: &str = "ami-0e95a5e2743ec9ec9"; // Amazon Linux 2 +const AWS_REGION: &str = "us-west-2"; +const AWS_INSTANCE_AMI: &str = "ami-055a9df0c8c9f681c"; // Amazon Linux 2 impl ReusableHosts { pub fn new(host_type: HostType) -> Self { @@ -44,7 +44,7 @@ impl ReusableHosts { project, }, HostType::Aws => InitializedHostType::Aws { - network: AwsNetwork::new("us-east-1", None), + network: AwsNetwork::new(AWS_REGION, None), }, HostType::Localhost => InitializedHostType::Localhost, }; diff --git a/hydro_optimize/src/deploy_and_analyze.rs b/hydro_optimize/src/deploy_and_analyze.rs index 3b67f49..0bda91f 100644 --- a/hydro_optimize/src/deploy_and_analyze.rs +++ b/hydro_optimize/src/deploy_and_analyze.rs @@ -25,7 +25,7 @@ const COUNTER_PREFIX: &str = "_optimize_counter"; pub(crate) const CPU_USAGE_PREFIX: &str = "HYDRO_OPTIMIZE_CPU:"; pub(crate) const NETWORK_USAGE_PREFIX: &str = "HYDRO_OPTIMIZE_NET:"; pub(crate) const LATENCY_PREFIX: &str = "HYDRO_OPTIMIZE_LAT:"; -pub const THROUGHPUT_PREFIX: &str = "HYDRO_OPTIMIZE_THR:"; +pub(crate) const THROUGHPUT_PREFIX: &str = "HYDRO_OPTIMIZE_THR:"; // Note: Ensure edits to the match arms are consistent with inject_count_node fn insert_counter_node(node: &mut HydroNode, next_stmt_id: &mut usize, duration: syn::Expr) { diff --git a/hydro_optimize/src/lib.rs b/hydro_optimize/src/lib.rs index 20c7122..634ee8d 100644 --- a/hydro_optimize/src/lib.rs +++ b/hydro_optimize/src/lib.rs @@ -1,4 +1,5 @@ -stageleft::stageleft_no_entry_crate!(); +#[cfg(stageleft_runtime)] +hydro_lang::setup!(); pub mod debug; pub mod decouple_analysis; @@ -16,12 +17,4 @@ pub mod rewrites; #[cfg(doctest)] mod docs { include_mdtests::include_mdtests!("docs/**/*.md*"); -} - -#[cfg(test)] -mod test_init { - #[ctor::ctor] - fn init() { - hydro_lang::deploy::init_test(); - } -} +} \ No newline at end of file diff --git a/hydro_optimize/src/parse_results.rs b/hydro_optimize/src/parse_results.rs index 219d705..5beb274 100644 --- a/hydro_optimize/src/parse_results.rs +++ b/hydro_optimize/src/parse_results.rs @@ -1,17 +1,11 @@ use std::collections::HashMap; -use std::time::Duration; -use crate::deploy_and_analyze::{LATENCY_PREFIX, THROUGHPUT_PREFIX}; -use hdrhistogram::Histogram; use hydro_lang::compile::deploy::DeployResult; use hydro_lang::compile::ir::{HydroNode, HydroRoot, traverse_dfir}; use hydro_lang::deploy::HydroDeploy; use hydro_lang::deploy::deploy_graph::DeployCrateWrapper; use hydro_lang::location::dynamic::LocationId; -use hydro_std::bench_client::AggregateBenchResult; -use hydro_std::bench_client::rolling_average::RollingAverage; use regex::Regex; -use stageleft::q; use tokio::sync::mpsc::UnboundedReceiver; use crate::deploy_and_analyze::MetricLogs; @@ -104,51 +98,6 @@ pub fn parse_network_usage(lines: Vec) -> NetworkStats { } } -pub fn print_parseable_bench_results<'a, Aggregator>( - aggregate_results: AggregateBenchResult<'a, Aggregator>, - interval_millis: u64, -) { - aggregate_results - .throughput - .filter_map(q!(move |(throughputs, num_client_machines): ( - RollingAverage, - usize - )| { - if let Some((lower, upper)) = throughputs.confidence_interval_99() { - Some(( - lower * num_client_machines as f64, - throughputs.sample_mean() * num_client_machines as f64, - upper * num_client_machines as f64, - )) - } else { - None - } - })) - .for_each(q!(move |(lower, mean, upper)| { - println!( - "{} {:.2} - {:.2} - {:.2} requests/s", - THROUGHPUT_PREFIX, lower, mean, upper, - ); - })); - aggregate_results - .latency - .map(q!(move |latencies: Histogram| ( - Duration::from_nanos(latencies.value_at_quantile(0.5)).as_micros() as f64 - / interval_millis as f64, - Duration::from_nanos(latencies.value_at_quantile(0.99)).as_micros() as f64 - / interval_millis as f64, - Duration::from_nanos(latencies.value_at_quantile(0.999)).as_micros() as f64 - / interval_millis as f64, - latencies.len(), - ))) - .for_each(q!(move |(p50, p99, p999, num_samples)| { - println!( - "{} p50: {:.3} | p99 {:.3} | p999 {:.3} ms ({:} samples)", - LATENCY_PREFIX, p50, p99, p999, num_samples - ); - })); -} - /// Parses throughput output from `print_parseable_bench_results`. /// Format: "HYDRO_OPTIMIZE_THR: {lower:.2} - {mean:.2} - {upper:.2} requests/s" /// Returns the last (lower, mean, upper) tuple found. diff --git a/hydro_optimize_examples/Cargo.toml b/hydro_optimize_examples/Cargo.toml index 19dc137..c7017dc 100644 --- a/hydro_optimize_examples/Cargo.toml +++ b/hydro_optimize_examples/Cargo.toml @@ -8,10 +8,10 @@ edition = "2024" all-features = true [dependencies] +hdrhistogram = "7.5.4" hydro_lang.workspace = true hydro_std.workspace = true hydro_test.workspace = true -hydro_optimize = { path = "../hydro_optimize" } serde.workspace = true sha2 = "0.10.9" stageleft.workspace = true @@ -24,6 +24,7 @@ dfir_lang.workspace = true hydro_build_utils.workspace = true hydro_deploy.workspace = true hydro_lang = { workspace = true, features = ["deploy", "viz", "sim"] } +hydro_optimize = { path = "../hydro_optimize" } regex.workspace = true [build-dependencies] diff --git a/hydro_optimize_examples/examples/benchmark_paxos.rs b/hydro_optimize_examples/examples/benchmark_paxos.rs index 79043e8..7198843 100644 --- a/hydro_optimize_examples/examples/benchmark_paxos.rs +++ b/hydro_optimize_examples/examples/benchmark_paxos.rs @@ -4,7 +4,7 @@ use hydro_optimize::deploy::{HostType, ReusableHosts}; use hydro_optimize::deploy_and_analyze::{ Optimizations, ReusableClusters, ReusableProcesses, deploy_and_optimize, }; -use hydro_optimize::parse_results::print_parseable_bench_results; +use hydro_optimize_examples::print_parseable_bench_results; use hydro_test::cluster::paxos::{CorePaxos, PaxosConfig}; #[derive(Parser, Debug)] diff --git a/hydro_optimize_examples/src/lib.rs b/hydro_optimize_examples/src/lib.rs index 01b5ce3..aa1960c 100644 --- a/hydro_optimize_examples/src/lib.rs +++ b/hydro_optimize_examples/src/lib.rs @@ -1,4 +1,5 @@ -stageleft::stageleft_no_entry_crate!(); +#[cfg(stageleft_runtime)] +hydro_lang::setup!(); pub mod network_calibrator; pub mod simple_kv_bench; @@ -6,10 +7,57 @@ pub mod lock_server; // pub mod lobsters; // pub mod web_submit; -#[cfg(test)] -mod test_init { - #[ctor::ctor] - fn init() { - hydro_lang::deploy::init_test(); - } -} +use std::time::Duration; +use hdrhistogram::Histogram; +use hydro_std::bench_client::{AggregateBenchResult, rolling_average::RollingAverage}; +use stageleft::q; + +/// Note: Must remain synchronized with definitions in hydro_optimize/deploy_and_analyze. +/// Redefined here because we don't want to import hydro_optimize as a dependency. +const LATENCY_PREFIX: &str = "HYDRO_OPTIMIZE_LAT:"; +const THROUGHPUT_PREFIX: &str = "HYDRO_OPTIMIZE_THR:"; + +pub fn print_parseable_bench_results<'a, Aggregator>( + aggregate_results: AggregateBenchResult<'a, Aggregator>, + interval_millis: u64, +) { + aggregate_results + .throughput + .filter_map(q!(move |(throughputs, num_client_machines): ( + RollingAverage, + usize + )| { + if let Some((lower, upper)) = throughputs.confidence_interval_99() { + Some(( + lower * num_client_machines as f64, + throughputs.sample_mean() * num_client_machines as f64, + upper * num_client_machines as f64, + )) + } else { + None + } + })) + .for_each(q!(move |(lower, mean, upper)| { + println!( + "{} {:.2} - {:.2} - {:.2} requests/s", + THROUGHPUT_PREFIX, lower, mean, upper, + ); + })); + aggregate_results + .latency + .map(q!(move |latencies: Histogram| ( + Duration::from_nanos(latencies.value_at_quantile(0.5)).as_micros() as f64 + / interval_millis as f64, + Duration::from_nanos(latencies.value_at_quantile(0.99)).as_micros() as f64 + / interval_millis as f64, + Duration::from_nanos(latencies.value_at_quantile(0.999)).as_micros() as f64 + / interval_millis as f64, + latencies.len(), + ))) + .for_each(q!(move |(p50, p99, p999, num_samples)| { + println!( + "{} p50: {:.3} | p99 {:.3} | p999 {:.3} ms ({:} samples)", + LATENCY_PREFIX, p50, p99, p999, num_samples + ); + })); +} \ No newline at end of file diff --git a/hydro_optimize_examples/src/network_calibrator.rs b/hydro_optimize_examples/src/network_calibrator.rs index 5a6360c..ee90645 100644 --- a/hydro_optimize_examples/src/network_calibrator.rs +++ b/hydro_optimize_examples/src/network_calibrator.rs @@ -3,11 +3,12 @@ use hydro_lang::{ nondet::nondet, prelude::{Cluster, KeyedStream, Process, TCP, Unbounded}, }; -use hydro_optimize::parse_results::print_parseable_bench_results; use hydro_std::bench_client::{aggregate_bench_results, bench_client, compute_throughput_latency}; use stageleft::q; +use crate::print_parseable_bench_results; + pub struct Client; pub struct Server; pub struct Aggregator; diff --git a/hydro_optimize_examples/src/simple_kv_bench.rs b/hydro_optimize_examples/src/simple_kv_bench.rs index 29a0e44..c4be272 100644 --- a/hydro_optimize_examples/src/simple_kv_bench.rs +++ b/hydro_optimize_examples/src/simple_kv_bench.rs @@ -3,12 +3,13 @@ use hydro_lang::{ nondet::nondet, prelude::{Cluster, Process, TCP}, }; -use hydro_optimize::parse_results::print_parseable_bench_results; use hydro_std::bench_client::{aggregate_bench_results, bench_client, compute_throughput_latency}; use hydro_test::cluster::paxos_bench::inc_i32_workload_generator; use stageleft::q; +use crate::print_parseable_bench_results; + pub struct Kv; pub struct Client; pub struct Aggregator; From 63c6fbd10bfa46753dbc2f0ed2eb346836380da9 Mon Sep 17 00:00:00 2001 From: David Chu Date: Wed, 4 Feb 2026 10:52:26 -0800 Subject: [PATCH 33/35] Fixes --- hydro_optimize_examples/examples/partition_two_pc.rs | 2 +- hydro_optimize_examples/src/lib.rs | 4 ++-- hydro_optimize_examples/src/simple_kv_bench.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/hydro_optimize_examples/examples/partition_two_pc.rs b/hydro_optimize_examples/examples/partition_two_pc.rs index 243db19..b26b24d 100644 --- a/hydro_optimize_examples/examples/partition_two_pc.rs +++ b/hydro_optimize_examples/examples/partition_two_pc.rs @@ -6,7 +6,7 @@ use hydro_optimize::deploy::{HostType, ReusableHosts}; use hydro_optimize::deploy_and_analyze::{ Optimizations, ReusableClusters, ReusableProcesses, deploy_and_optimize, }; -use hydro_optimize::parse_results::print_parseable_bench_results; +use hydro_optimize_examples::print_parseable_bench_results; use hydro_test::cluster::two_pc_bench::{Aggregator, Client}; #[derive(Parser, Debug)] diff --git a/hydro_optimize_examples/src/lib.rs b/hydro_optimize_examples/src/lib.rs index aa1960c..28a242d 100644 --- a/hydro_optimize_examples/src/lib.rs +++ b/hydro_optimize_examples/src/lib.rs @@ -14,8 +14,8 @@ use stageleft::q; /// Note: Must remain synchronized with definitions in hydro_optimize/deploy_and_analyze. /// Redefined here because we don't want to import hydro_optimize as a dependency. -const LATENCY_PREFIX: &str = "HYDRO_OPTIMIZE_LAT:"; -const THROUGHPUT_PREFIX: &str = "HYDRO_OPTIMIZE_THR:"; +pub(crate) const LATENCY_PREFIX: &str = "HYDRO_OPTIMIZE_LAT:"; +pub(crate) const THROUGHPUT_PREFIX: &str = "HYDRO_OPTIMIZE_THR:"; pub fn print_parseable_bench_results<'a, Aggregator>( aggregate_results: AggregateBenchResult<'a, Aggregator>, diff --git a/hydro_optimize_examples/src/simple_kv_bench.rs b/hydro_optimize_examples/src/simple_kv_bench.rs index c4be272..400da40 100644 --- a/hydro_optimize_examples/src/simple_kv_bench.rs +++ b/hydro_optimize_examples/src/simple_kv_bench.rs @@ -77,11 +77,11 @@ mod tests { deploy::{DeployCrateWrapper, HydroDeploy, TrybuildHost}, prelude::FlowBuilder, }; - use hydro_optimize::deploy_and_analyze::THROUGHPUT_PREFIX; use std::str::FromStr; use regex::Regex; + use crate::THROUGHPUT_PREFIX; #[cfg(stageleft_runtime)] use crate::simple_kv_bench::simple_kv_bench; From 6a84e715c7549761fdca23b70f38ab006e09d029 Mon Sep 17 00:00:00 2001 From: David Chu Date: Wed, 4 Feb 2026 13:24:33 -0800 Subject: [PATCH 34/35] Remove fragile tests --- hydro_optimize/src/decoupler.rs | 190 ------------------ .../src/simple_kv_bench.rs | 31 +-- 2 files changed, 1 insertion(+), 220 deletions(-) diff --git a/hydro_optimize/src/decoupler.rs b/hydro_optimize/src/decoupler.rs index c24c3ec..c6d483b 100644 --- a/hydro_optimize/src/decoupler.rs +++ b/hydro_optimize/src/decoupler.rs @@ -297,193 +297,3 @@ pub fn decouple( true, ); } - -#[cfg(test)] -mod tests { - use std::collections::HashSet; - - use hydro_build_utils::insta; - use hydro_deploy::Deployment; - use hydro_lang::compile::builder::FlowBuilder; - use hydro_lang::compile::built::BuiltFlow; - use hydro_lang::compile::ir; - use hydro_lang::location::Location; - use hydro_lang::nondet::nondet; - use hydro_lang::prelude::{Cluster, TCP}; - use stageleft::q; - - use crate::debug::{name_to_id_map, print_id}; - use crate::decoupler::{DecoupleDecision, Decoupler, decouple}; - use crate::repair::inject_id; - - fn decouple_mini_program<'a>( - output_to_decoupled_machine_after: Vec<(&str, i32)>, // name, offset - output_to_original_machine_after: Vec<(&str, i32)>, - place_on_decoupled_machine: Vec<(&str, i32)>, - ) -> ( - Cluster<'a, ()>, - Cluster<'a, ()>, - Cluster<'a, ()>, - BuiltFlow<'a>, - ) { - let mut builder = FlowBuilder::new(); - let send_cluster = builder.cluster::<()>(); - let recv_cluster = builder.cluster::<()>(); - let decoupled_cluster = builder.cluster::<()>(); - - send_cluster - .source_iter(q!(0..10)) - .map(q!(|a| a + 1)) - .ir_node_named("map") - .broadcast(&recv_cluster, TCP.bincode(), nondet!(/** test */)) - .values() - .assume_ordering(nondet!(/** test */)) - .assume_retries(nondet!(/** test */)) - .for_each(q!(|a| println!("Got it: {}", a))); - - let built = builder.optimize_with(|ir| { - inject_id(ir); - print_id(ir); - // Convert named nodes to IDs, accounting for the offset - let name_to_id = name_to_id_map(ir); - let decoupler = Decoupler { - decision: DecoupleDecision { - output_to_decoupled_machine_after: output_to_decoupled_machine_after - .into_iter() - .map(|(name, offset)| { - (name_to_id.get(name).cloned().unwrap() as i32 + offset) as usize - }) - .collect(), - output_to_original_machine_after: output_to_original_machine_after - .into_iter() - .map(|(name, offset)| { - (name_to_id.get(name).cloned().unwrap() as i32 + offset) as usize - }) - .collect(), - place_on_decoupled_machine: place_on_decoupled_machine - .into_iter() - .map(|(name, offset)| { - (name_to_id.get(name).cloned().unwrap() as i32 + offset) as usize - }) - .collect(), - }, - decoupled_location: decoupled_cluster.id().clone(), - orig_location: send_cluster.id().clone(), - }; - decouple(ir, &decoupler); - }); - (send_cluster, recv_cluster, decoupled_cluster, built) - } - - async fn check_decouple_mini_program( - output_to_decoupled_machine_after: Vec<(&str, i32)>, // name, offset - output_to_original_machine_after: Vec<(&str, i32)>, - place_on_decoupled_machine: Vec<(&str, i32)>, - ) { - let (send_cluster, recv_cluster, decoupled_cluster, built) = decouple_mini_program( - output_to_decoupled_machine_after, - output_to_original_machine_after, - place_on_decoupled_machine, - ); - - // Check outputs - let mut deployment = Deployment::new(); - let nodes = built - .with_cluster(&send_cluster, vec![deployment.Localhost(); 1]) - .with_cluster(&recv_cluster, vec![deployment.Localhost(); 3]) - .with_cluster(&decoupled_cluster, vec![deployment.Localhost(); 1]) - .deploy(&mut deployment); - - deployment.deploy().await.unwrap(); - - let recv_members = nodes.get_cluster(&recv_cluster).members(); - let mut stdouts = vec![]; - for member in recv_members { - use hydro_lang::deploy::DeployCrateWrapper; - - stdouts.push(member.stdout()); - } - - deployment.start().await.unwrap(); - - for mut stdout in stdouts { - let mut expected = HashSet::new(); - let mut received = HashSet::new(); - for i in 1..11 { - received.insert(stdout.recv().await.unwrap()); - expected.insert(format!("Got it: {}", i)); - } - assert_eq!(expected, received); - } - } - - #[test] - fn decouple_after_source_ir() { - let output_to_decoupled_machine_after = vec![("map", -1)]; - let output_to_original_machine_after = vec![]; - let place_on_decoupled_machine = vec![ - // the source of cluster membership (TODO(shadaj): should have a better way of identifying) - ("map", -11), - ]; - - let built = decouple_mini_program( - output_to_decoupled_machine_after, - output_to_original_machine_after, - place_on_decoupled_machine, - ) - .3; - - ir::dbg_dedup_tee(|| { - insta::assert_debug_snapshot!(built.ir()); - }); - } - - #[tokio::test] - async fn decouple_after_source() { - let output_to_decoupled_machine_after = vec![("map", -1)]; - let output_to_original_machine_after = vec![]; - let place_on_decoupled_machine = vec![ - // the source of cluster membership (TODO(shadaj): should have a better way of identifying) - ("map", -11), - ]; - - check_decouple_mini_program( - output_to_decoupled_machine_after, - output_to_original_machine_after, - place_on_decoupled_machine, - ) - .await - } - - #[test] - fn move_source_decouple_map_ir() { - let output_to_decoupled_machine_after = vec![]; - let output_to_original_machine_after = vec![("map", 0)]; - let place_on_decoupled_machine = vec![("map", -1)]; - - let built = decouple_mini_program( - output_to_decoupled_machine_after, - output_to_original_machine_after, - place_on_decoupled_machine, - ) - .3; - - ir::dbg_dedup_tee(|| { - insta::assert_debug_snapshot!(built.ir()); - }); - } - - #[tokio::test] - async fn move_source_decouple_map() { - let output_to_decoupled_machine_after = vec![]; - let output_to_original_machine_after = vec![("map", 0)]; - let place_on_decoupled_machine = vec![("map", -1)]; - - check_decouple_mini_program( - output_to_decoupled_machine_after, - output_to_original_machine_after, - place_on_decoupled_machine, - ) - .await - } -} diff --git a/hydro_optimize_examples/src/simple_kv_bench.rs b/hydro_optimize_examples/src/simple_kv_bench.rs index 400da40..424e2e9 100644 --- a/hydro_optimize_examples/src/simple_kv_bench.rs +++ b/hydro_optimize_examples/src/simple_kv_bench.rs @@ -84,36 +84,7 @@ mod tests { use crate::THROUGHPUT_PREFIX; #[cfg(stageleft_runtime)] use crate::simple_kv_bench::simple_kv_bench; - - #[test] - fn simple_kv_ir() { - let mut builder = FlowBuilder::new(); - let kv = builder.process(); - let clients = builder.cluster(); - let client_aggregator = builder.process(); - let interval_millis = 1000; - - simple_kv_bench(1, &kv, &clients, &client_aggregator, interval_millis); - let mut built = builder.with_default_optimize::(); - - dbg_dedup_tee(|| { - insta::assert_debug_snapshot!(built.ir()); - }); - - let preview = built.preview_compile(); - insta::with_settings!({snapshot_suffix => "kv_mermaid"}, { - insta::assert_snapshot!( - preview.dfir_for(&kv).to_mermaid(&WriteConfig { - no_subgraphs: true, - no_pull_push: true, - no_handoffs: true, - op_text_no_imports: true, - ..WriteConfig::default() - }) - ); - }); - } - + #[tokio::test] async fn simple_kv_some_throughput() { let mut builder = FlowBuilder::new(); From e4ce8fc9beac9db91253ac4b93add486f7ba0e79 Mon Sep 17 00:00:00 2001 From: David Chu Date: Wed, 4 Feb 2026 13:33:09 -0800 Subject: [PATCH 35/35] cargo fmt & clippy --- docs/partitioning.mdx | 4 +-- hydro_optimize/src/decoupler.rs | 5 +--- hydro_optimize/src/deploy_and_analyze.rs | 29 +++++-------------- hydro_optimize/src/lib.rs | 2 +- hydro_optimize/src/parse_results.rs | 26 ++++++++--------- hydro_optimize/src/partitioner.rs | 4 +-- .../examples/benchmark_paxos.rs | 6 ++-- .../examples/network_calibrator.rs | 6 ++-- .../examples/partition_two_pc.rs | 7 ++--- .../examples/perf_paxos.rs | 6 ++-- hydro_optimize_examples/src/lib.rs | 6 ++-- .../src/network_calibrator.rs | 21 +++++++------- .../src/simple_kv_bench.rs | 27 ++++++++--------- 13 files changed, 65 insertions(+), 84 deletions(-) diff --git a/docs/partitioning.mdx b/docs/partitioning.mdx index 333313f..df372d7 100644 --- a/docs/partitioning.mdx +++ b/docs/partitioning.mdx @@ -160,7 +160,7 @@ Imagine `Chain` then joins with another stream, as in the following program. ```rust # use hydro_lang::prelude::*; fn chain_parents_same_input<'a, L>( - flow: FlowBuilder<'a>, + mut flow: FlowBuilder<'a>, input1: Stream<(usize, usize), Process<'a, L>, Unbounded>, input2: Stream<(usize, usize), Process<'a, L>, Unbounded>, ) { @@ -198,7 +198,7 @@ Imagine `Chain` then joins with another stream, as in the following program. ```rust # use hydro_lang::prelude::*; fn chain_parents_different_inputs<'a, L>( - flow: FlowBuilder<'a>, + mut flow: FlowBuilder<'a>, input1: Stream<(usize, usize), Process<'a, L>, Unbounded>, input2: Stream<(usize, usize), Process<'a, L>, Unbounded>, ) { diff --git a/hydro_optimize/src/decoupler.rs b/hydro_optimize/src/decoupler.rs index c6d483b..7acd2be 100644 --- a/hydro_optimize/src/decoupler.rs +++ b/hydro_optimize/src/decoupler.rs @@ -258,10 +258,7 @@ fn fix_cluster_self_id_node(node: &mut HydroNode, mut locations: ClusterSelfIdRe } } -pub fn decouple( - ir: &mut [HydroRoot], - decoupler: &Decoupler, -) { +pub fn decouple(ir: &mut [HydroRoot], decoupler: &Decoupler) { let tee_to_inner_id_before_rewrites = tee_to_inner_id(ir); let mut new_inners = HashMap::new(); traverse_dfir::( diff --git a/hydro_optimize/src/deploy_and_analyze.rs b/hydro_optimize/src/deploy_and_analyze.rs index 0bda91f..03483ff 100644 --- a/hydro_optimize/src/deploy_and_analyze.rs +++ b/hydro_optimize/src/deploy_and_analyze.rs @@ -179,17 +179,12 @@ impl Sidecar for ScriptSidecar { } } +#[derive(Default)] pub struct ReusableClusters { named_clusters: Vec<(LocationKey, String, usize)>, } impl ReusableClusters { - pub fn new() -> Self { - Self { - named_clusters: vec![], - } - } - pub fn with_cluster(mut self, cluster: Cluster<'_, C>, num_members: usize) -> Self { self.named_clusters.push(( cluster.id().key(), @@ -200,17 +195,12 @@ impl ReusableClusters { } } +#[derive(Default)] pub struct ReusableProcesses { named_processes: Vec<(LocationKey, String)>, } impl ReusableProcesses { - pub fn new() -> Self { - Self { - named_processes: vec![], - } - } - pub fn with_process

(mut self, process: Process<'_, P>) -> Self { self.named_processes .push((process.id().key(), std::any::type_name::

().to_string())); @@ -225,16 +215,18 @@ pub struct Optimizations { iterations: usize, // Must be at least 1 } -impl Optimizations { - pub fn new() -> Self { +impl Default for Optimizations { + fn default() -> Self { Self { - decoupling: false, - partitioning: false, + decoupling: true, + partitioning: true, exclude: vec![], iterations: 1, } } +} +impl Optimizations { pub fn with_decoupling(mut self) -> Self { self.decoupling = true; self @@ -257,11 +249,6 @@ impl Optimizations { } } -#[expect(clippy::too_many_arguments, reason = "Optimizer internal function")] -#[expect( - clippy::await_holding_refcell_ref, - reason = "Await function needs to write to data in RefCell" -)] pub async fn deploy_and_optimize<'a>( reusable_hosts: &mut ReusableHosts, deployment: &mut Deployment, diff --git a/hydro_optimize/src/lib.rs b/hydro_optimize/src/lib.rs index 634ee8d..42b41ea 100644 --- a/hydro_optimize/src/lib.rs +++ b/hydro_optimize/src/lib.rs @@ -17,4 +17,4 @@ pub mod rewrites; #[cfg(doctest)] mod docs { include_mdtests::include_mdtests!("docs/**/*.md*"); -} \ No newline at end of file +} diff --git a/hydro_optimize/src/parse_results.rs b/hydro_optimize/src/parse_results.rs index 5beb274..bcb999c 100644 --- a/hydro_optimize/src/parse_results.rs +++ b/hydro_optimize/src/parse_results.rs @@ -74,19 +74,19 @@ pub fn parse_network_usage(lines: Vec) -> NetworkStats { Regex::new(r"eth0\s+(\d+\.?\d*)\s+(\d+\.?\d*)\s+(\d+\.?\d*)\s+(\d+\.?\d*)").unwrap(); for line in &lines { - if let Some(caps) = eth0_regex.captures(line) { - if let (Ok(rx_pkt), Ok(tx_pkt), Ok(rx_kb), Ok(tx_kb)) = ( + if let Some(caps) = eth0_regex.captures(line) + && let (Ok(rx_pkt), Ok(tx_pkt), Ok(rx_kb), Ok(tx_kb)) = ( caps[1].parse::(), caps[2].parse::(), caps[3].parse::(), caps[4].parse::(), - ) { - rx_pkt_samples.push(rx_pkt); - tx_pkt_samples.push(tx_pkt); - // Convert kB/s to bytes/s - rx_kb_samples.push(rx_kb * 1024.0); - tx_kb_samples.push(tx_kb * 1024.0); - } + ) + { + rx_pkt_samples.push(rx_pkt); + tx_pkt_samples.push(tx_pkt); + // Convert kB/s to bytes/s + rx_kb_samples.push(rx_kb * 1024.0); + tx_kb_samples.push(tx_kb * 1024.0); } } @@ -115,7 +115,7 @@ pub fn parse_throughput(lines: Vec) -> (f64, f64, f64) { ) }) }) - .last() + .next_back() .unwrap() } @@ -136,7 +136,7 @@ pub fn parse_latency(lines: Vec) -> (f64, f64, f64, u64) { ) }) }) - .last() + .next_back() .unwrap() } @@ -222,8 +222,8 @@ pub fn inject_perf(ir: &mut [HydroRoot], folded_data: Vec) -> f64 { /// Returns (op_id, count) pub fn parse_counter_usage(lines: Vec, op_to_count: &mut HashMap) { + let regex = Regex::new(r"\((\d+)\): (\d+)").unwrap(); for measurement in lines { - let regex = Regex::new(r"\((\d+)\): (\d+)").unwrap(); let matches = regex.captures_iter(&measurement).last().unwrap(); let op_id = matches[1].parse::().unwrap(); let count = matches[2].parse::().unwrap(); @@ -337,7 +337,7 @@ pub async fn analyze_cluster_results( ir: &mut [HydroRoot], mut cluster_metrics: HashMap<(LocationId, String, usize), MetricLogs>, run_metadata: &mut RunMetadata, - exclude: &Vec, + exclude: &[String], ) -> (LocationId, String, usize) { let mut max_usage_cluster_id = None; let mut max_usage_cluster_size = 0; diff --git a/hydro_optimize/src/partitioner.rs b/hydro_optimize/src/partitioner.rs index 96d3ee7..68c42a9 100644 --- a/hydro_optimize/src/partitioner.rs +++ b/hydro_optimize/src/partitioner.rs @@ -77,7 +77,7 @@ fn replace_membership_info(node: &mut HydroNode, partitioner: &Partitioner, op_i node.visit_debug_expr(|expr| { let mut visitor = ClusterMembersReplace { num_partitions: *num_partitions, - location_id: location_id.clone(), + location_id: *location_id, op_id, }; visitor.visit_expr_mut(&mut expr.0); @@ -85,7 +85,7 @@ fn replace_membership_info(node: &mut HydroNode, partitioner: &Partitioner, op_i node.visit_debug_expr(|expr| { let mut visitor = ClusterSelfIdReplace::Partition { num_partitions: *num_partitions, - partitioned_cluster_id: location_id.clone(), + partitioned_cluster_id: *location_id, op_id, }; visitor.visit_expr_mut(&mut expr.0); diff --git a/hydro_optimize_examples/examples/benchmark_paxos.rs b/hydro_optimize_examples/examples/benchmark_paxos.rs index 7198843..2a79862 100644 --- a/hydro_optimize_examples/examples/benchmark_paxos.rs +++ b/hydro_optimize_examples/examples/benchmark_paxos.rs @@ -86,13 +86,13 @@ async fn run_benchmark( reusable_hosts, deployment, builder.finalize(), - ReusableClusters::new() + ReusableClusters::default() .with_cluster(proposers, f + 1) .with_cluster(acceptors, 2 * f + 1) .with_cluster(clients, num_clients) .with_cluster(replicas, f + 1), - ReusableProcesses::new().with_process(client_aggregator), - Optimizations::new(), + ReusableProcesses::default().with_process(client_aggregator), + Optimizations::default(), Some(run_seconds), ) .await; diff --git a/hydro_optimize_examples/examples/network_calibrator.rs b/hydro_optimize_examples/examples/network_calibrator.rs index db6a002..d59e016 100644 --- a/hydro_optimize_examples/examples/network_calibrator.rs +++ b/hydro_optimize_examples/examples/network_calibrator.rs @@ -70,11 +70,11 @@ async fn main() { &mut reusable_hosts, &mut deployment, builder.finalize(), - ReusableClusters::new() + ReusableClusters::default() .with_cluster(server, 1) .with_cluster(clients, num_clients), - ReusableProcesses::new().with_process(client_aggregator), - Optimizations::new() + ReusableProcesses::default().with_process(client_aggregator), + Optimizations::default() .excluding::() .excluding::(), num_seconds_to_profile, diff --git a/hydro_optimize_examples/examples/partition_two_pc.rs b/hydro_optimize_examples/examples/partition_two_pc.rs index b26b24d..71b76e7 100644 --- a/hydro_optimize_examples/examples/partition_two_pc.rs +++ b/hydro_optimize_examples/examples/partition_two_pc.rs @@ -1,4 +1,3 @@ - use clap::{ArgAction, Parser}; use hydro_deploy::Deployment; use hydro_lang::viz::config::GraphConfig; @@ -69,13 +68,13 @@ async fn main() { &mut reusable_hosts, &mut deployment, builder.finalize(), - ReusableClusters::new() + ReusableClusters::default() .with_cluster(participants, num_participants) .with_cluster(clients, num_clients), - ReusableProcesses::new() + ReusableProcesses::default() .with_process(coordinator) .with_process(client_aggregator), - Optimizations::new() + Optimizations::default() .with_partitioning() .excluding::() .excluding::(), diff --git a/hydro_optimize_examples/examples/perf_paxos.rs b/hydro_optimize_examples/examples/perf_paxos.rs index bfcc42b..1d37e36 100644 --- a/hydro_optimize_examples/examples/perf_paxos.rs +++ b/hydro_optimize_examples/examples/perf_paxos.rs @@ -88,13 +88,13 @@ async fn main() { &mut reusable_hosts, &mut deployment, builder.finalize(), - ReusableClusters::new() + ReusableClusters::default() .with_cluster(proposers, f + 1) .with_cluster(acceptors, 2 * f + 1) .with_cluster(clients, num_clients) .with_cluster(replicas, f + 1), - ReusableProcesses::new().with_process(client_aggregator), - Optimizations::new() + ReusableProcesses::default().with_process(client_aggregator), + Optimizations::default() .with_decoupling() .excluding::() .excluding::() diff --git a/hydro_optimize_examples/src/lib.rs b/hydro_optimize_examples/src/lib.rs index 28a242d..d059e8a 100644 --- a/hydro_optimize_examples/src/lib.rs +++ b/hydro_optimize_examples/src/lib.rs @@ -1,16 +1,16 @@ #[cfg(stageleft_runtime)] hydro_lang::setup!(); +pub mod lock_server; pub mod network_calibrator; pub mod simple_kv_bench; -pub mod lock_server; // pub mod lobsters; // pub mod web_submit; -use std::time::Duration; use hdrhistogram::Histogram; use hydro_std::bench_client::{AggregateBenchResult, rolling_average::RollingAverage}; use stageleft::q; +use std::time::Duration; /// Note: Must remain synchronized with definitions in hydro_optimize/deploy_and_analyze. /// Redefined here because we don't want to import hydro_optimize as a dependency. @@ -60,4 +60,4 @@ pub fn print_parseable_bench_results<'a, Aggregator>( LATENCY_PREFIX, p50, p99, p999, num_samples ); })); -} \ No newline at end of file +} diff --git a/hydro_optimize_examples/src/network_calibrator.rs b/hydro_optimize_examples/src/network_calibrator.rs index ee90645..4cf09a0 100644 --- a/hydro_optimize_examples/src/network_calibrator.rs +++ b/hydro_optimize_examples/src/network_calibrator.rs @@ -24,9 +24,7 @@ pub fn network_calibrator<'a>( let latencies = bench_client( clients, num_clients_per_node, - |ids_and_prev_payloads| { - size_based_workload_generator(message_size, ids_and_prev_payloads) - }, + |ids_and_prev_payloads| size_based_workload_generator(message_size, ids_and_prev_payloads), |payloads| { // Server just echoes the payload payloads @@ -36,10 +34,13 @@ pub fn network_calibrator<'a>( .values() .into_keyed() }, - ).values().map(q!(|(_client_id, latency)| latency)); + ) + .values() + .map(q!(|(_client_id, latency)| latency)); let bench_results = compute_throughput_latency(clients, latencies, nondet!(/** bench */)); - let aggregate_results = aggregate_bench_results(bench_results, client_aggregator, clients, interval_millis); + let aggregate_results = + aggregate_bench_results(bench_results, client_aggregator, clients, interval_millis); print_parseable_bench_results(aggregate_results, interval_millis); } @@ -55,11 +56,11 @@ pub fn size_based_workload_generator<'a, Client>( >, ) -> KeyedStream, Cluster<'a, Client>, Unbounded, NoOrder> { ids_and_prev_payloads.map(q!(move |payload| { - if let Some(mut payload) = payload { - if let Some(last) = payload.last_mut() { - *last += 1; - return payload; - } + if let Some(mut payload) = payload + && let Some(last) = payload.last_mut() + { + *last += 1; + return payload; } // Temp fix for macro stuff that isn't supported by stageleft I guess diff --git a/hydro_optimize_examples/src/simple_kv_bench.rs b/hydro_optimize_examples/src/simple_kv_bench.rs index 424e2e9..5384d14 100644 --- a/hydro_optimize_examples/src/simple_kv_bench.rs +++ b/hydro_optimize_examples/src/simple_kv_bench.rs @@ -69,12 +69,9 @@ pub fn simple_kv_bench<'a>( #[cfg(test)] mod tests { - use dfir_lang::graph::WriteConfig; - use hydro_build_utils::insta; use hydro_deploy::Deployment; use hydro_lang::{ - compile::ir::dbg_dedup_tee, - deploy::{DeployCrateWrapper, HydroDeploy, TrybuildHost}, + deploy::{DeployCrateWrapper, TrybuildHost}, prelude::FlowBuilder, }; use std::str::FromStr; @@ -84,7 +81,7 @@ mod tests { use crate::THROUGHPUT_PREFIX; #[cfg(stageleft_runtime)] use crate::simple_kv_bench::simple_kv_bench; - + #[tokio::test] async fn simple_kv_some_throughput() { let mut builder = FlowBuilder::new(); @@ -112,19 +109,19 @@ mod tests { deployment.start().await.unwrap(); - let re = Regex::new(r"(\d+\.?\d*)\s*-\s*(\d+\.?\d*)\s*-\s*(\d+\.?\d*)\s*requests/s").unwrap(); + let re = + Regex::new(r"(\d+\.?\d*)\s*-\s*(\d+\.?\d*)\s*-\s*(\d+\.?\d*)\s*requests/s").unwrap(); let mut found = 0; let mut client_out = client_out; while let Some(line) = client_out.recv().await { - if let Some(caps) = re.captures(&line) { - if let Ok(lower) = f64::from_str(&caps[1]) { - if lower > 0.0 { - println!("Found throughput lower-bound: {}", lower); - found += 1; - if found == 2 { - break; - } - } + if let Some(caps) = re.captures(&line) + && let Ok(lower) = f64::from_str(&caps[1]) + && lower > 0.0 + { + println!("Found throughput lower-bound: {}", lower); + found += 1; + if found == 2 { + break; } } }