diff --git a/bandwidth-comparison-topologies.ipynb b/bandwidth-comparison-topologies.ipynb new file mode 100644 index 0000000..e1c57ed --- /dev/null +++ b/bandwidth-comparison-topologies.ipynb @@ -0,0 +1,668 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1e953690", + "metadata": {}, + "source": [ + "# Bandwidth Comparison Across Topologies\n", + "\n", + "Compare gossipsub, WFR-enhanced gossipsub, and grid topologies across bandwidth caps. Each combination runs across multiple seeds (averages recorded) and feeds into summary plots." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "fc0d5e1e", + "metadata": {}, + "outputs": [], + "source": [ + "# Ensure the stdlib random module is available despite the local random.py helper.\n", + "import importlib.machinery\n", + "import importlib.util\n", + "import os\n", + "import subprocess\n", + "import sys\n", + "\n", + "def ensure_stdlib_random() -> None:\n", + " stdlib_random_path = os.path.join(os.path.dirname(os.__file__), \"random.py\")\n", + " loader = importlib.machinery.SourceFileLoader(\"random\", stdlib_random_path)\n", + " spec = importlib.util.spec_from_loader(\"random\", loader)\n", + " module = importlib.util.module_from_spec(spec)\n", + " loader.exec_module(module)\n", + " sys.modules[\"random\"] = module\n", + "\n", + "ensure_stdlib_random()\n", + "\n", + "try:\n", + " import pandas as pd\n", + " import seaborn as sns\n", + "except ModuleNotFoundError:\n", + " subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"pandas\", \"seaborn\"])\n", + " import pandas as pd\n", + " import seaborn as sns\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import beamsim\n", + "from concurrent.futures import ThreadPoolExecutor, as_completed\n", + "\n", + "sns.set_theme(style=\"whitegrid\")\n", + "plt.rcParams[\"figure.figsize\"] = (12, 6)\n", + "plt.rcParams[\"axes.titlesize\"] = 13" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "0157592a", + "metadata": {}, + "outputs": [], + "source": [ + "DEFAULT_CONFIG = {\n", + " \"backend\": \"ns3-direct\",\n", + " \"snark1_pull\": True,\n", + " \"snark1_half_direct\": True,\n", + " \"signature_half_direct\": 0,\n", + " \"shuffle\": False,\n", + " \"random_seed\": 42,\n", + " \"group_count\": 8,\n", + " \"group_validator_count\": 1024,\n", + " \"group_local_aggregator_count\": \"10%\",\n", + " \"global_aggregator_count\": 102,\n", + " \"mesh_n\": 8,\n", + " \"non_mesh_n\": 4,\n", + " \"idontwant\": False,\n", + " \"signature_time\": \"20ms\",\n", + " \"signature_size\": 3072,\n", + " \"snark_size\": 131072,\n", + " \"snark1_threshold\": 0.9,\n", + " \"snark2_threshold\": 0.66,\n", + " \"aggregation_rate_per_sec\": 1000,\n", + " \"snark_recursion_aggregation_rate_per_sec\": 10,\n", + " \"pq_signature_verification_time\": \"30us\",\n", + " \"snark_proof_verification_time\": \"5ms\",\n", + " \"gml\": \"shadow-atlas.bin\",\n", + " \"max_bitrate\": \"50Mbps\",\n", + "}\n", + "\n", + "BANDWIDTH_CAPS = [\"25Mbps\", \"50Mbps\", \"100Mbps\", \"200Mbps\"]\n", + "\n", + "# Adjust MAX_WORKERS to tune concurrency across topology/bandwidth combinations.\n", + "MAX_WORKERS = 3\n", + "SEED_BASE = 42\n", + "NUM_SEEDS = 1\n", + "SEED_VALUES = [SEED_BASE + i for i in range(NUM_SEEDS)]\n", + "\n", + "TOPOLOGY_VARIANTS = [\n", + " {\n", + " \"name\": \"gossipsub\",\n", + " \"label\": \"gossipsub\",\n", + " \"topology\": \"gossip\",\n", + " \"config_overrides\": {},\n", + " \"wfr_overrides\": None,\n", + " },\n", + " {\n", + " \"name\": \"wfr-gossipsub\",\n", + " \"label\": \"wfr-gossipsub\",\n", + " \"topology\": \"gossip\",\n", + " \"config_overrides\": {},\n", + " \"wfr_overrides\": {\n", + " \"robust\": 4,\n", + " },\n", + " },\n", + " {\n", + " \"name\": \"grid\",\n", + " \"label\": \"grid\",\n", + " \"topology\": \"grid\",\n", + " \"config_overrides\": {},\n", + " \"wfr_overrides\": None,\n", + " },\n", + "]\n", + "\n", + "def bool_to_yaml(value: bool) -> str:\n", + " if not isinstance(value, bool):\n", + " raise TypeError(f\"Expected a bool, got {type(value)!r}\")\n", + " return str(value).lower()\n", + "\n", + "def generate_yaml_config(*, topology: str = \"gossip\", wfr: dict | None = None, **overrides) -> str:\n", + " config = {**DEFAULT_CONFIG, **overrides}\n", + " config[\"topology\"] = topology\n", + " lines = [\n", + " \"# Simulation Backend Configuration\",\n", + " f\"backend: {config['backend']}\",\n", + " \"\",\n", + " f\"snark1_pull: {bool_to_yaml(config['snark1_pull'])}\",\n", + " f\"snark1_half_direct: {bool_to_yaml(config['snark1_half_direct'])}\",\n", + " f\"signature_half_direct: {config['signature_half_direct']}\",\n", + " \"\",\n", + " \"# Network Topology Configuration\",\n", + " f\"topology: {config['topology']}\",\n", + " \"\",\n", + " \"# Whether to shuffle validators from the same group to different routers\",\n", + " f\"shuffle: {bool_to_yaml(config['shuffle'])}\",\n", + " \"\",\n", + " \"# Seed for reproducible simulation results\",\n", + " f\"random_seed: {config['random_seed']}\",\n", + " \"\",\n", + " \"# Role Assignment Configuration\",\n", + " \"roles:\",\n", + " f\" group_count: {config['group_count']}\",\n", + " f\" group_validator_count: {config['group_validator_count']}\",\n", + " f\" group_local_aggregator_count: {config['group_local_aggregator_count']}\",\n", + " f\" global_aggregator_count: {config['global_aggregator_count']}\",\n", + " \"\",\n", + " \"# Gossipsub Network Configuration\",\n", + " \"gossip:\",\n", + " f\" mesh_n: {config['mesh_n']}\",\n", + " f\" non_mesh_n: {config['non_mesh_n']}\",\n", + " f\" idontwant: {bool_to_yaml(config['idontwant'])}\",\n", + " ]\n", + " if topology == \"gossip\" and wfr:\n", + " lines.append(\" wfr:\")\n", + " if \"robust\" in wfr:\n", + " lines.append(f\" robust: {wfr['robust']}\")\n", + " lines.extend(\n", + " [\n", + " \"\",\n", + " \"# Cryptographic Constants\",\n", + " \"consts:\",\n", + " f\" signature_time: {config['signature_time']}\",\n", + " f\" signature_size: {config['signature_size']}\",\n", + " f\" snark_size: {config['snark_size']}\",\n", + " f\" snark1_threshold: {config['snark1_threshold']}\",\n", + " f\" snark2_threshold: {config['snark2_threshold']}\",\n", + " f\" aggregation_rate_per_sec: {config['aggregation_rate_per_sec']}\",\n", + " f\" snark_recursion_aggregation_rate_per_sec: {config['snark_recursion_aggregation_rate_per_sec']}\",\n", + " f\" pq_signature_verification_time: {config['pq_signature_verification_time']}\",\n", + " f\" snark_proof_verification_time: {config['snark_proof_verification_time']}\",\n", + " \"\",\n", + " \"# Network Simulation Parameters\",\n", + " \"network:\",\n", + " f\" gml: \\\"{config['gml']}\\\"\",\n", + " ]\n", + " )\n", + " if config[\"max_bitrate\"] is not None:\n", + " lines.append(f\" max_bitrate: {config['max_bitrate']}\")\n", + " return beamsim.yaml(\"\\n\".join(lines))\n", + "\n", + "def extract_metrics(items):\n", + " snark1_rows = beamsim.get_snark1_received(items)\n", + " snark1_completion = None\n", + " if snark1_rows:\n", + " snark1_completion = snark1_rows[-1][0]\n", + " else:\n", + " snark1_sent_xs, _ = beamsim.get_snark1_sent(items)\n", + " if snark1_sent_xs and len(snark1_sent_xs) > 1:\n", + " snark1_completion = snark1_sent_xs[-1]\n", + " duplicates = None\n", + " duplicates_avg = None\n", + " try:\n", + " duplicates, duplicates_avg = beamsim.get_signature_duplicates(items)\n", + " except Exception:\n", + " pass\n", + " validator_count = None\n", + " snark1_threshold = None\n", + " try:\n", + " info_row = beamsim.filter_report(items, \"info\")[0]\n", + " validator_count = info_row[2]\n", + " snark1_threshold = info_row[3]\n", + " except Exception:\n", + " pass\n", + " return snark1_completion, duplicates, duplicates_avg, validator_count, snark1_threshold\n", + "\n", + "def run_single_configuration(topo_cfg: dict, bandwidth: str, seeds: list[int]) -> dict:\n", + " snark1_times = []\n", + " duplicate_counts = []\n", + " duplicate_avgs = []\n", + " validator_count = None\n", + " snark1_threshold = None\n", + " errors = []\n", + " for seed in seeds:\n", + " overrides = {\n", + " **topo_cfg.get(\"config_overrides\", {}),\n", + " \"max_bitrate\": bandwidth,\n", + " \"random_seed\": seed,\n", + " }\n", + " try:\n", + " yaml_path = generate_yaml_config(\n", + " topology=topo_cfg[\"topology\"],\n", + " wfr=topo_cfg.get(\"wfr_overrides\"),\n", + " **overrides,\n", + " )\n", + " items = beamsim.run(\n", + " b=DEFAULT_CONFIG[\"backend\"],\n", + " t=topo_cfg[\"topology\"],\n", + " c=yaml_path,\n", + " local_aggregation_only=True,\n", + " )\n", + " snark1_completion, dup_count, dup_avg, validator_count, snark1_threshold = extract_metrics(items)\n", + " if snark1_completion is not None:\n", + " snark1_times.append(snark1_completion)\n", + " if dup_count is not None:\n", + " duplicate_counts.append(dup_count)\n", + " if dup_avg is not None:\n", + " duplicate_avgs.append(dup_avg)\n", + " except Exception as exc:\n", + " errors.append(str(exc))\n", + " num_successes = len(snark1_times)\n", + " result = {\n", + " \"topology\": topo_cfg[\"label\"],\n", + " \"topology_key\": topo_cfg[\"name\"],\n", + " \"bandwidth\": bandwidth,\n", + " \"snark1_completion_ms\": float(np.mean(snark1_times)) if snark1_times else np.nan,\n", + " \"snark1_completion_std_ms\": float(np.std(snark1_times, ddof=1)) if len(snark1_times) > 1 else (0.0 if snark1_times else np.nan),\n", + " \"duplicate_count\": float(np.mean(duplicate_counts)) if duplicate_counts else np.nan,\n", + " \"duplicate_avg\": float(np.mean(duplicate_avgs)) if duplicate_avgs else np.nan,\n", + " \"num_seeds\": num_successes,\n", + " \"total_seeds\": len(seeds),\n", + " \"validator_count\": validator_count,\n", + " \"snark1_threshold\": snark1_threshold,\n", + " \"error\": \"; \".join(errors) if errors else None,\n", + " }\n", + " return result" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "520576a3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "run: build/beamsim -c /var/folders/r9/53ggp_3x6w51pqj8_kv1_lb00000gn/T/beamsim-yaml-md5/adc588fe00488365fb54d07cc6749225 -b ns3-direct -t gossip --local-aggregation-only --report\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
topologytopology_keybandwidthsnark1_completion_mssnark1_completion_std_msduplicate_countduplicate_avgnum_seedstotal_seedsvalidator_countsnark1_thresholderror
0gossipsubgossipsub25Mbps4605.00.01027.01.116304111024921None
1gossipsubgossipsub50Mbps2980.00.01168.01.269565111024921None
2gossipsubgossipsub100Mbps2404.00.0688.00.747826111024921None
3gossipsubgossipsub200Mbps2306.00.01366.01.483170111024921None
4wfr-gossipsubwfr-gossipsub25Mbps4198.00.01061.01.139635111024921None
5wfr-gossipsubwfr-gossipsub50Mbps2660.00.0784.00.850325111024921None
6wfr-gossipsubwfr-gossipsub100Mbps2345.00.0971.01.052004111024921None
7wfr-gossipsubwfr-gossipsub200Mbps2177.00.0893.00.970652111024921None
8gridgrid25Mbps2838.00.0451.00.490217111024921None
9gridgrid50Mbps2313.00.0437.00.475000111024921None
10gridgrid100Mbps1830.00.0415.00.451087111024921None
11gridgrid200Mbps1394.00.0501.00.544565111024921None
\n", + "
" + ], + "text/plain": [ + " topology topology_key bandwidth snark1_completion_ms \\\n", + "0 gossipsub gossipsub 25Mbps 4605.0 \n", + "1 gossipsub gossipsub 50Mbps 2980.0 \n", + "2 gossipsub gossipsub 100Mbps 2404.0 \n", + "3 gossipsub gossipsub 200Mbps 2306.0 \n", + "4 wfr-gossipsub wfr-gossipsub 25Mbps 4198.0 \n", + "5 wfr-gossipsub wfr-gossipsub 50Mbps 2660.0 \n", + "6 wfr-gossipsub wfr-gossipsub 100Mbps 2345.0 \n", + "7 wfr-gossipsub wfr-gossipsub 200Mbps 2177.0 \n", + "8 grid grid 25Mbps 2838.0 \n", + "9 grid grid 50Mbps 2313.0 \n", + "10 grid grid 100Mbps 1830.0 \n", + "11 grid grid 200Mbps 1394.0 \n", + "\n", + " snark1_completion_std_ms duplicate_count duplicate_avg num_seeds \\\n", + "0 0.0 1027.0 1.116304 1 \n", + "1 0.0 1168.0 1.269565 1 \n", + "2 0.0 688.0 0.747826 1 \n", + "3 0.0 1366.0 1.483170 1 \n", + "4 0.0 1061.0 1.139635 1 \n", + "5 0.0 784.0 0.850325 1 \n", + "6 0.0 971.0 1.052004 1 \n", + "7 0.0 893.0 0.970652 1 \n", + "8 0.0 451.0 0.490217 1 \n", + "9 0.0 437.0 0.475000 1 \n", + "10 0.0 415.0 0.451087 1 \n", + "11 0.0 501.0 0.544565 1 \n", + "\n", + " total_seeds validator_count snark1_threshold error \n", + "0 1 1024 921 None \n", + "1 1 1024 921 None \n", + "2 1 1024 921 None \n", + "3 1 1024 921 None \n", + "4 1 1024 921 None \n", + "5 1 1024 921 None \n", + "6 1 1024 921 None \n", + "7 1 1024 921 None \n", + "8 1 1024 921 None \n", + "9 1 1024 921 None \n", + "10 1 1024 921 None \n", + "11 1 1024 921 None " + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "future_to_meta = {}\n", + "results = []\n", + "with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:\n", + " for topo_cfg in TOPOLOGY_VARIANTS:\n", + " for bandwidth in BANDWIDTH_CAPS:\n", + " future = executor.submit(run_single_configuration, topo_cfg, bandwidth, SEED_VALUES)\n", + " future_to_meta[future] = (topo_cfg, bandwidth)\n", + " for future in as_completed(future_to_meta):\n", + " topo_cfg, bandwidth = future_to_meta[future]\n", + " try:\n", + " result = future.result()\n", + " except Exception as exc:\n", + " result = {\n", + " \"topology\": topo_cfg[\"label\"],\n", + " \"topology_key\": topo_cfg[\"name\"],\n", + " \"bandwidth\": bandwidth,\n", + " \"snark1_completion_ms\": np.nan,\n", + " \"snark1_completion_std_ms\": np.nan,\n", + " \"duplicate_count\": np.nan,\n", + " \"duplicate_avg\": np.nan,\n", + " \"num_seeds\": 0,\n", + " \"total_seeds\": len(SEED_VALUES),\n", + " \"validator_count\": None,\n", + " \"snark1_threshold\": None,\n", + " \"error\": str(exc),\n", + " }\n", + " results.append(result)\n", + "\n", + "combined_results_df = pd.DataFrame(results)\n", + "combined_results_df[\"bandwidth\"] = pd.Categorical(combined_results_df[\"bandwidth\"], categories=BANDWIDTH_CAPS, ordered=True)\n", + "combined_results_df[\"topology\"] = pd.Categorical(combined_results_df[\"topology\"], categories=[cfg[\"label\"] for cfg in TOPOLOGY_VARIANTS], ordered=True)\n", + "\n", + "numeric_columns = [\n", + " \"snark1_completion_ms\",\n", + " \"snark1_completion_std_ms\",\n", + " \"duplicate_count\",\n", + " \"duplicate_avg\",\n", + "]\n", + "for column in numeric_columns:\n", + " if column in combined_results_df:\n", + " combined_results_df[column] = pd.to_numeric(combined_results_df[column], errors=\"coerce\")\n", + "\n", + "combined_results_df.sort_values([\"topology\", \"bandwidth\"], inplace=True)\n", + "combined_results_df.reset_index(drop=True, inplace=True)\n", + "combined_results_df" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "aee64e13", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_df = combined_results_df[combined_results_df[\"error\"].isna()].copy()\n", + "if not plot_df.empty:\n", + " fig, axes = plt.subplots(1, 2, figsize=(14, 6), sharex=True)\n", + " sns.lineplot(\n", + " data=plot_df,\n", + " x=\"bandwidth\",\n", + " y=\"snark1_completion_ms\",\n", + " hue=\"topology\",\n", + " marker=\"o\",\n", + " ax=axes[0],\n", + " )\n", + " axes[0].set_title(\"SNARK1 completion time by bandwidth\")\n", + " axes[0].set_ylabel(\"Completion time (ms)\")\n", + " axes[0].set_xlabel(\"Bandwidth cap\")\n", + " sns.lineplot(\n", + " data=plot_df,\n", + " x=\"bandwidth\",\n", + " y=\"duplicate_avg\",\n", + " hue=\"topology\",\n", + " marker=\"o\",\n", + " ax=axes[1],\n", + " )\n", + " axes[1].set_title(\"Average duplicate signatures\")\n", + " axes[1].set_ylabel(\"Duplicates per signature\")\n", + " axes[1].set_xlabel(\"Bandwidth cap\")\n", + " axes[0].legend(title=\"Topology\", loc=\"upper left\")\n", + " axes[1].legend().remove()\n", + " plt.tight_layout()\n", + "else:\n", + " print(\"No successful runs to visualize.\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "beamsim", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/cli.hpp b/cli.hpp index b9f1665..5cb46bc 100644 --- a/cli.hpp +++ b/cli.hpp @@ -709,6 +709,9 @@ struct SimulationConfig { yaml.at({"gossip", "mesh_n"}).get(gossip_config.mesh_n); yaml.at({"gossip", "non_mesh_n"}).get(gossip_config.non_mesh_n); yaml.at({"gossip", "idontwant"}).get(gossip_config.idontwant); + if (auto yaml_wfr_robust = yaml.at({"gossip", "wfr", "robust"})) { + yaml_wfr_robust.get(gossip_config.wfr_robust.emplace()); + } auto &consts = beamsim::consts(); yaml.at({"consts", "signature_time"}).get(consts.signature_time); diff --git a/main.cpp b/main.cpp index 498371a..3ccfbc4 100644 --- a/main.cpp +++ b/main.cpp @@ -314,7 +314,8 @@ namespace beamsim::example { auto source_group = getGroupFromPeerIndices(ihave->peer_indices); // If the group has already contributed, ignore this ihave - if (snark1_received_groups_.get(source_group) and snark1_received_ihave_groups_.get(source_group)) { + if (snark1_received_groups_.get(source_group) + and snark1_received_ihave_groups_.get(source_group)) { report(simulator_, "snark1_ihave_ignored_duplicate_group", source_group); @@ -425,7 +426,8 @@ namespace beamsim::example { consts().snark_proof_verification_time, [this, message, forward] { // Smart push at global aggregators: forward and process only once per group - auto source_group = getGroupFromPeerIndices(message.peer_indices); + auto source_group = + getGroupFromPeerIndices(message.peer_indices); if (snark1_pushed_groups_.get(source_group)) { report(simulator_, "snark1_smart_push_ignored_duplicate_group", @@ -884,6 +886,12 @@ void run_simulation(const SimulationConfig &config) { .stop_on_create_snark1 = config.local_aggregation_only, }; + shared_state.gossip_config.wfr_latency = [&](beamsim::PeerIndex peer1, + beamsim::PeerIndex peer2) { + return std::chrono::milliseconds{ + routers.directWire(peer1, peer2).delay_ms}; + }; + beamsim::example::report(simulator, "info", roles.validator_count, diff --git a/src/beamsim/gossip/config.hpp b/src/beamsim/gossip/config.hpp index 1b924e8..e63798a 100644 --- a/src/beamsim/gossip/config.hpp +++ b/src/beamsim/gossip/config.hpp @@ -1,11 +1,17 @@ #pragma once #include +#include +#include namespace beamsim::gossip { struct Config { PeerIndex mesh_n = 4; PeerIndex non_mesh_n = 4; bool idontwant = false; + + std::optional wfr_robust; + std::function wfr_latency; + Time wfr_latency_threshold = std::chrono::milliseconds{1}; }; } // namespace beamsim::gossip diff --git a/src/beamsim/gossip/peer.hpp b/src/beamsim/gossip/peer.hpp index 60d036c..fd2081a 100644 --- a/src/beamsim/gossip/peer.hpp +++ b/src/beamsim/gossip/peer.hpp @@ -84,8 +84,8 @@ namespace beamsim::gossip { } dontwant_.emplace(from_peer, message_hash); dontwant_.emplace(publish.origin, message_hash); - on_gossip(publish.message, [this, publish, message_hash] { - _gossip(publish, message_hash); + on_gossip(publish.message, [this, from_peer, publish, message_hash] { + _gossip(publish, message_hash, from_peer); }); } for (auto &message_hash : gossip_message.iwant) { @@ -117,17 +117,43 @@ namespace beamsim::gossip { if (not duplicate_cache_.emplace(message_hash).second) { return; } - _gossip({topic_index, peer_.peer_index_, any_message}, message_hash); + _gossip({topic_index, peer_.peer_index_, any_message}, + message_hash, + std::nullopt); } private: - void _gossip(const Publish &publish, MessageHash message_hash) { + void _gossip(const Publish &publish, + MessageHash message_hash, + std::optional from_peer) { mcache_.emplace(message_hash, publish); history_[publish.topic_index].add(message_hash); + std::vector peers; for (auto &to_peer : views_.at(publish.topic_index).publishTo()) { + if (to_peer == from_peer) { + continue; + } if (dontwant_.contains({to_peer, message_hash})) { continue; } + peers.emplace_back(to_peer); + } + if (from_peer.has_value() and config_.wfr_robust.has_value() + and config_.wfr_latency != nullptr + and *config_.wfr_robust < peers.size()) { + random_.shuffle(peers); + peers.erase(std::remove_if(peers.begin() + *config_.wfr_robust, + peers.end(), + [&](PeerIndex to_peer) { + return config_.wfr_latency( + peer_.peer_index_, to_peer) + > config_.wfr_latency( + *from_peer, peer_.peer_index_) + + config_.wfr_latency_threshold; + }), + peers.end()); + } + for (auto &to_peer : peers) { getBatch(to_peer).publish.emplace_back(publish); } }