2b:null 2c:["$","title",null,{"children":"libp2p-perf-blog-post-2 | libp2p | Observable"}] 31:T4f4,## Network performance metrics *How does one measure network performance?* Evaluating network performance is not as straightforward as it might initially appear. This complexity stems from the multidimensional nature of performance metrics in networking. Different metrics cater to various aspects of network functionality, and each metric's relevance varies according to the specific use-case scenario. The primary metric categories for today are latency, throughput, and resource usage. - Latency - E.g. *how much time does it take to establish a connection?* - Relevant e.g. when establishing many connections for a Kademlia query. - Throughput - E.g. *how many bytes can one send from A to B in one second.* - Relevant e.g. when exchanging a large blob of data via BitSwap. - Resource Usage - E.g. *how much CPU time does it take to send X bytes from A to B?* - Relevant e.g. when running a large GossipSub network on resource constrained hardware. It is important to stress that this effort is only concerned with transport level performance. It does not measure or simulate higher-level protocols directly, like a Kademlia query or a BitSwap exchange. That said, transport protocol performance has a direct impact on these upper level protocols.32:T663,{ // Create a container div to hold all the plots const containerDiv = document.createElement("div"); // Iterate through each benchmark in the data.benchmarks array for (const benchmark of data.benchmarks) { // Extract the results from the current benchmark const results = benchmark.results; // Group the results by implementation const groups = new Map(); for (const r of results) { const implAndTransport = `${r.implementation}/${r.transportStack}`; if (!groups.has(implAndTransport)) { groups.set(implAndTransport, []); } groups.get(implAndTransport).push(r); } // Create traces for each implementation const traces = []; for (const [impl, results] of groups) { traces.push({ x: results.map((r, i) => i - results.length + 1), y: results.map(r => { const p = d3.quantile(r.result.sort((a, b) => a - b), percentile); console.log(p); return p }), mode: "lines+markers", name: impl, type: "scatter", text: results.map(r => `${impl}/${r.version}`), hovertemplate: '%{text}
%{y}', }); } // Create a div to hold the plot for the current benchmark const plotDiv = document.createElement("div"); // Create a plot with Plotly inside the div Plotly.newPlot(plotDiv, traces, { title: benchmark.name, xaxis: { title: "Version" }, yaxis: { title: benchmark.unit }, hovermode: "closest" }); // Append the plot div for the current benchmark to the container div containerDiv.appendChild(plotDiv); } // Return the container div with all the plots return containerDiv; }33:T545,latencyBoxPlot = function(implementations) { // Create a trace for the pings data const baseline = { y: data.pings.results, type: 'box', name: 'Ping Results', }; const name = "Connection establishment + 1 byte round trip latencies"; const benchmark = data.benchmarks.filter(benchmark => benchmark.name === name)[0]; // Filter and map over the implementations to get all matching results const allResults = implementations.flatMap(implementation => { const regex = new RegExp(implementation); return benchmark.results.filter(result => regex.test(`${result.implementation}/${result.version}/${result.transportStack}`) ); }); // Now create an array of traces for each valid result const traces = allResults.map(result => { return { y: result.result, type: 'box', name: `${result.implementation}/${result.version}/${result.transportStack}`, }; }); traces.unshift(baseline); // Create the layout for the plot const layout = { title: name, yaxis: { title: `${benchmark.unit}` }, }; // Create a container element for the plot const container = DOM.element('div'); container.style.width = '100%'; container.style.height = '500px'; // Render the plot return Plotly.newPlot(container, traces, layout).then(() => { return container; }); } 34:T6c9,throughputBoxPlot = function(implementations) { // Define the benchmark name const name = "Single Connection throughput – Upload 100 MiB"; const benchmark = data.benchmarks.filter(benchmark => benchmark.name === name)[0]; console.log(benchmark); // Filter and map over the implementations to get all matching results const allResults = implementations.flatMap(implementation => { const regex = new RegExp(implementation); return benchmark.results.filter(result => regex.test(`${result.implementation}/${result.version}/${result.transportStack}`) ); }); console.log(allResults); // Now create an array of traces for each valid result const traces = allResults.map(result => { // Calculate total throughput (bit/s) const totalBytes = benchmark.parameters.downloadBytes + benchmark.parameters.uploadBytes; const throughput = result.result.map(res => (totalBytes * 8) / res); // Multiply by 8 to convert bytes to bits console.log("throughput"); console.log(throughput); return { y: throughput, type: 'box', name: `${result.implementation}/${result.version}/${result.transportStack}`, }; }); const baseline = { y: data.iperf.results, type: 'box', name: 'iPerf Results', }; traces.unshift(baseline); // Create the layout for the plot const layout = { title: name, yaxis: { title: `Total Throughput (bit/s)`, tickformat: ".4s" }, }; // Create a container element for the plot const container = DOM.element('div'); container.style.width = '100%'; container.style.height = '500px'; // Render the plot return Plotly.newPlot(container, traces, layout).then(() => { return container; }); } 35:[{"id":"1ec3edc43ba66c0db419744c479d1b5118bb405587189f3ad739a10853f6f933d86824e809f4b4ad18053ab33fb5dc7c5f3d6bc601654c8ea976afd5b321f517","href":"https://static.observableusercontent.com/files/1ec3edc43ba66c0db419744c479d1b5118bb405587189f3ad739a10853f6f933d86824e809f4b4ad18053ab33fb5dc7c5f3d6bc601654c8ea976afd5b321f517","name":"counties-albers-10m.json","type":"application/json","lastModified":1692004019490.634,"size":795407}] 2f:{"id":"765378eddb93bd8b","slug":null,"title":"libp2p-perf-blog-post-2","thumbnail":"cc6fd66d1f2c9b8358bac72e8941362e2f47f1f538685c4217c24fa04594879e","access_level":"public","create_time":"$D2023-08-14T09:06:59.490Z","update_time":"$D2023-08-14T09:08:03.847Z","view_time":null,"first_public_time":"$D2023-08-14T09:06:59.490Z","has_unpublished_edits":null,"fork":{"id":"e059bcffb455f2a9","slug":"libp2p-perf-blog-post-1","title":"libp2p Performance","owner":{"id":"e44e38c5cad4f544","login":"libp2p-workspace","name":"libp2p"}},"stars":0,"starred":false,"owner":{"type":"team","id":"e44e38c5cad4f544","login":"libp2p-workspace","name":"libp2p","avatar_url":"https://avatars-next.observableusercontent.com/df0dddc14551e19aacd810a947ba0823cae6226927247d2fad2ac8d32bdd8120","tier":"starter_2024"},"version":882,"publish_version":null,"role":null,"authored":false,"authors":[{"type":"individual","id":"3136c9b24d8fa3a9","login":"mxinden","name":"Max Inden","avatar_url":"https://avatars-next.observableusercontent.com/07c2b70c5368f2813f9c993b46e5b51856f6d7dee115eb6b1fb7f4ec799d01d8","tier":null}],"members":[{"type":"team","id":"e44e38c5cad4f544","login":"libp2p-workspace","name":"libp2p","avatar_url":"https://avatars-next.observableusercontent.com/df0dddc14551e19aacd810a947ba0823cae6226927247d2fad2ac8d32bdd8120","tier":"starter_2024","role":"editor"},{"type":"individual","id":"3136c9b24d8fa3a9","login":"mxinden","name":"Max Inden","avatar_url":"https://avatars-next.observableusercontent.com/07c2b70c5368f2813f9c993b46e5b51856f6d7dee115eb6b1fb7f4ec799d01d8","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"lapsed":null,"subscribed":null,"forks":0,"collection":null,"type":"notebook","body":{"title":"libp2p-perf-blog-post-2","cells":[{"id":122,"value":"# libp2p-perf-blog-post-2\n\n_or how fast is libp2p?_\n\nIntroducing the [libp2p performance tooling](https://github.com/libp2p/test-plans/tree/master/perf).\n\n**Note this is still work-in-progress.**\n\nTODO (reword) Prepare yourself for lots of data, boxplots and deep dive into the various network stacks.\n\nTODO: Should we do two blog-posts one with latency one with througput. Too long for one blog post. Attention span this long of a reader?\n\n\n\n\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":401,"value":"toc({ selector: \"h2,h3,h4,h5,h6\", heading: \"Table of contents\" });","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":416,"value":"$31","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":496,"value":"## The *perf* protocol\n\n*What protocol can we use to test these network performance metrics?*\n\nThe libp2p *perf* protocol is a client-driven protocol inspired [by Nick Bank's QUIC Performance Internet-Draft](https://datatracker.ietf.org/doc/html/draft-banks-quic-performance#section-2.3), but adapted for libp2p. It functions by having the client open a libp2p stream to the server, tell the server the amount of bytes it wants to receive, optionally write some data to the stream, then close the write side of the stream. The server reads the client's byte request, reads from the stream until an EOF signal is reached, and sends the requested number of bytes back to the client.\n\nThis flexible protocol allows for various benchmarks, including measurement of connection establishment latency or connection throughput. ","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":709,"value":"mermaid`sequenceDiagram\n participant Client\n participant Server\n Client->>Server: Open libp2p stream\n Client->>Server: Send number of bytes to be received\n Client->>Server: Write some data to the stream\n Client->>Server: Close the write side of the stream\n Server->>Client: Send the number of bytes back to the client\n Server->>Client: Close the stream\n\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":176,"value":"## Benchmark setup\n\n*How do we get a reproducible environment to test libp2p performance?*\n\n- Fully reproducible for anyone, using terraform. You can run this yourself.\n- We spin up two machines in us-west-2 and us-east-1\n- See `perf/terraform` in https://github.com/libp2p/test-plans/pull/163/\n- Feel free to skip ahead in case you are only interested in the benchmark results.\n- Link to readme in pull request.\n\nTODO: Expand on cloud instances, distance, ...\n\nFor the curious, take a look at https://github.com/mxinden/test-plans/blob/perf-terraform/perf/terraform/terraform.tf\n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":480,"value":"So let's spin up our infrastructure:\n\n``` bash\ncd libp2p/test-plans/perf/terraform\nterraform apply\n```","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":472,"value":"This will spin up two machines, one in `us-east-1` (the client) and one in `us-west-2` (the server).","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":284,"value":"map = {// Create a container for the map\nconst container = html`

`;\nyield container;\n\n// Initialize the map and set its view to be centered in the United States\nconst map = L.map(container, {\n dragging: false,\n touchZoom: false,\n scrollWheelZoom: false,\n doubleClickZoom: false,\n boxZoom: false,\n keyboard: false\n}).setView([39.8283, -98.5795], 4);\n\n// Add the OpenStreetMap tile layer to the map\nL.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {\n attribution: '© OpenStreetMap contributors'\n}).addTo(map);\n\n// Define the coordinates for US-East-1 (Northern Virginia) and US-West-2 (Oregon)\nconst locations = [\n { name: 'US-East-1', coordinates: [37.4316, -78.6569] },\n { name: 'US-West-2', coordinates: [44.0, -120.5014] }\n];\n\n// Add markers for each location\nfor (const location of locations) {\n L.marker(location.coordinates).addTo(map)\n .bindPopup(`${location.name}`)\n .openPopup();\n}\n}\n","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":484,"value":"In addition to the infrastructure provisioning scripts, we automated the benchmark execution via a small tool that we call the _runner_. Let's fire it up:\n\n``` bash\ncd libp2p/test-plans/perf/runner\nnpm run start -- --client-public-ip $(terraform output -raw -state ../terraform/terraform.tfstate client_public_ip) --server-public-ip $(terraform output -raw -state ../terraform/terraform.tfstate server_public_ip)\n```\n\n- It takes as input the IP of the server and client machines.\n- It builds the various implementations (quic-go, https, go-libp2p, rust-libp2p ...) on the machines.\n- For each implementation and benchmark\n - It starts the server.\n - It starts the client.\n - It captures the results.\n- Once done, it stores the benchmark results as a JSON file on your local machine. Checkout `benchmark-results.json`.\n\nNow that we have the benchmark results, let's pull them into this notebook. \n","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":5,"value":"data = {\n const data = await fetch(\"https://raw.githubusercontent.com/mxinden/test-plans/perf-terraform/perf/runner/benchmark-results.json\").then((response) => response.json());\n\nlet targetBenchmarks = data.benchmarks.filter(benchmark => benchmark.name === \"Connection establishment + 1 byte round trip latencies\");\ndata.benchmarks.map(benchmark => {\n benchmark.results.forEach(result => {\n result.result = result.result.map(timeObj => {\n let totalSeconds = timeObj.connectionEstablishedSeconds + timeObj.uploadSeconds + timeObj.downloadSeconds;\n return Number(totalSeconds.toFixed(3));\n });\n });\n});\n\n data.benchmarks.forEach(benchmark => {\n benchmark.results.sort((a, b) => {\n if (a.version < b.version) {\n return -1;\n } else if (a.version > b.version) {\n return 1;\n } else {\n return 0;\n }\n });\n});\n \n return data\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":487,"value":"Neat. Expand the above JSON object to see the raw data. We have all we need. Let's explore it.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":273,"value":"## Latency\n\n*What is network latency? Why is it important?*\n\nTODO: How about a TLDR with all results at the very beginning?\n\n- One of our important performance metrics is latency. Link to the earlier paragraph on the different metrics to measure.\n- What is latency.\n\n### Baseline using ping\n\n*It is hard to get an intuition for latency. What would be a baseline?*\n\n- Our benchmark runner measures latency.\n- How does it do that?\n- Using icmp ping\n- xxx executions from the client to the server\n\nLet's visualize the ping latency between the two machines as a boxplot:","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":349,"value":"{\n // Create a trace for the pings data\n const trace = {\n y: data.pings.results,\n type: 'box',\n name: 'Ping Results',\n };\n\n // Create the layout for the plot\n const layout = {\n title: 'Ping Results',\n yaxis: { title: `Ping Time (${data.pings.unit})` },\n };\n\n // Create the data array for the plot\n const data2 = [trace];\n\n // Create a container element for the plot\n const container = DOM.element('div');\n container.style.width = '100%';\n container.style.height = '500px';\n\n // Render the plot\n return Plotly.newPlot(container, data2, layout).then(() => {\n return container;\n });\n}\n","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":380,"value":"md`\nTODO explain how a boxplot works.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":449,"value":"Why do we look at this. Well it helps us interpret the results below, namely how fast one can establish a connection, in other words it gives us a maximum baseline on connection establishment. Great. Let's take a look at the numbers.\n\nTODO Stress that one can not just use ping to transfer data (security, flow control, streams, ...)\n\n### HTTP/2 with TLS over TCP\n\n*Everyone is familiar with the HTTP/2 with TLS over TCP. How does it perform in this environment?*\n\nTo begin with, we start with something everyone is familiar with, HTTPs. We wrote a small wrapper around the Go standard library HTTPs implementation. TODO link to it.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":506,"value":"latencyBoxPlot([\"https\"])\n","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":548,"value":"mermaid`\nsequenceDiagram\n participant Client\n participant Server\n\n Note over Client,Server: TCP Handshake\n Client->>Server: SYN\n Server->>Client: SYN-ACK\n Client->>Server: ACK\n\n Note over Client,Server: TLS Handshake\n Client->>Server: ClientHello\n Server->>Client: ServerHello\n Server->>Client: Finished\n Client->>Server: Finished\n\n Note over Client,Server: HTTP Request\n Client->>Server: HTTP Request\n Server->>Client: HTTP Response\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":560,"value":"md`When you count the number of round trips in the sequence diagram above, you should end up at 3. And in the above boxplot, https is 3x slower than our baseline using ICMP Ping.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":616,"value":"### libp2p with TLS over TCP\n\n*How does libp2p do on top of TCP?*\n\nJust like HTTP/2 can run on TCP and TLS, libp2p can as well.\n\nLet's take a look at connection establishment latency of libp2p when using TCP and TLS.\n\nTODO This might be using Noise. Explains the go-libp2p higher latency as it has to negotiate security multiplexer.\n\nTODO Display box plots next to each other to make it easier to compare.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":621,"value":"latencyBoxPlot([\"https\", \".*-libp2p.*tcp\"])","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":613,"value":"md`Great. This makes sense. Now time has moved on and TCP+TLS+HTTP is no longer cool. Instead let's take a look at QUIC.\n\n### QUIC\n\n*How does vanilla QUIC compare to TCP?*\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":592,"value":"latencyBoxPlot([\"https\", \"quic-go\"])","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":694,"value":"md`*Why is QUIC faster than TCP?*\n\nFor that we need to look at the QUIC handshake.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":588,"value":"mermaid`\nsequenceDiagram\n participant Client\n participant Server\n\n Note over Client,Server: Server authentication\n Client->>Server: ClientHello\n Server->>Client: ServerHello\n Server->>Client: Finished\n Client->>Server: Finished\n\n Note over Client,Server: Request / Response\n Client->>Server: Request\n Server->>Client: Response\n\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":720,"value":"md`TODO:\n- ping 1rtt\n- quic 2rtt\n- https 3rtt\n\nCompare with the numbers from the boxplot.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":634,"value":"Now that we know how vanilla QUIC performs, let's take a look at libp2p on top of QUIC.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":659,"value":"md`\n### libp2p over QUIC\n\n*How does libp2p on top of QUIC compare to vanilla QUIC?*\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":686,"value":"latencyBoxPlot([\"https\", \"quic-go\", \".*-libp2p/.*quic.*\"])","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":715,"value":"TODO: Why is quic-go one round-trip faster? Is it the go-libp2p identify round trip?","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":676,"value":"md`\n### request latency\n\nTODO should we fight the misconception that streams are expensive in libp2p in this post as well? Or for another blog post?\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":396,"value":"## Throughput\n\n\n### Small Detour - Bandwidth delay product\n\nQuick detour. Helps understand the baseline and the implementations below.\n\nAlso talk about the problem about send and receive windows, required to do retransmits of any packet within the bandwidth delay product.\n\nTODO: Most values use the upload test only.\n\n### Baseline using iperf\n\nTODO Is this bits or bytes?","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":431,"value":"{\n // Create a trace for the iperf data\n const trace = {\n y: data.iperf.results,\n type: 'box',\n name: 'iPerf Results',\n };\n\n // Create the layout for the plot\n const layout = {\n title: 'iPerf Results',\n yaxis: { title: `Throughput (${data.iperf.unit})`, tickformat: \".4s\" },\n };\n\n // Create the data array for the plot\n const data2 = [trace];\n\n // Create a container element for the plot\n const container = DOM.element('div');\n container.style.width = '100%';\n container.style.height = '500px';\n\n // Render the plot\n return Plotly.newPlot(container, data2, layout).then(() => {\n return container;\n });\n}\n","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":440,"value":"{const iperfCopy = data.iperf.results.slice(); // Create a copy of the array\n\nconst p = d3.quantile(iperfCopy.sort((a, b) => a - b), 0.95).toFixed(4);\nconst u = data.iperf.unit;\n\nreturn md`So the 95th percentile throughput between the two nodes is ${p} ${u}.`;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":451,"value":"### HTTP/2 with TLS over TCP","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":737,"value":"throughputBoxPlot([\"https\"])","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":758,"value":"### libp2p with TLS over TCP","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":765,"value":"throughputBoxPlot([\"https\", \".*-libp2p.*tcp\"])","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":638,"value":"### QUIC","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":753,"value":"throughputBoxPlot([\"https\", \"quic-go\"])","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":770,"value":"TODO why is quic-go slower than https here?","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":640,"value":"### libp2p over QUIC","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":755,"value":"throughputBoxPlot([\"https\", \"quic-go\", \".*-libp2p/.*quic-v1\"])","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":399,"value":"## Performance over time (across releases)","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":178,"value":"Choose a percentile to filter outliers from the dataset.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":135,"value":"viewof percentile = Inputs.range([0, 1], {value: 0.95, step: 0.05, label: \"Percentile\"})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":233,"value":"$32","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":723,"value":"## Further reading\n\n*Where can I learn more?*\n\n- https://connectivity.libp2p.io/\n- https://github.com/libp2p/specs/\n- The usual other suspects","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":425,"value":"**Supporting Code and Libraries for this Notebook**","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","output":"","database":"$undefined"},{"id":393,"value":"Plotly = require(\"https://cdn.plot.ly/plotly-latest.min.js\")","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":404,"value":"import {toc} from \"@harrystevens/toc@126\"","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":596,"value":"$33","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":733,"value":"$34","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":799,"value":"L = {\n const L = await require(\"leaflet@1/dist/leaflet.js\");\n if (!L._style) {\n const href = await require.resolve(\"leaflet@1/dist/leaflet.css\");\n document.head.appendChild(L._style = html``);\n }\n return L;\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":336,"value":"countiesAlbers10m1 = FileAttachment(\"counties-albers-10m.json\").json()","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W35","stdlib":"1","titling":"auto"}} 30:"$2f:body"