Merge pull request #25 from c410-f3r/misc

HTTP/2

Author: c410-f3r

.github/workflows/deploy.yml

@@ -17,12 +17,12 @@ jobs:
         with:
           override: true
           profile: minimal
-          toolchain: nightly-2024-02-19
+          toolchain: nightly-2024-04-27
       - uses: Swatinem/rust-cache@v2
       - run: |
           cd evaluator
-          cargo build --release --features deploy
-          cargo run --release --features deploy -- "Shared GitHub runner"
+          cargo build --release --features all-protocols,deploy
+          cargo run --release --features all-protocols,deploy -- "Shared GitHub runner"
           cd ../site
           npm install
           npm run build

.github/workflows/tests.yml

@@ -15,7 +15,7 @@ jobs:
           components: clippy, rustfmt
           override: true
           profile: minimal
-          toolchain: nightly-2024-02-19
+          toolchain: nightly-2024-04-27
       - uses: Swatinem/rust-cache@v2
       - run: |
           cd evaluator

evaluator/Cargo.lock

@@ -1,10 +1,13 @@
 [dependencies]
 flate2 = { default-features = false, features = ["rust_backend"], version = "1.0" }
 tokio = { default-features = false, features = ["fs", "io-std", "macros", "process", "rt-multi-thread"], version = "1.0" }
-wtx = { branch = "http2", default-features = false, features = ["http2", "optimization", "pool", "tokio", "tokio-rustls", "webpki-roots", "web-socket-handshake"], git = "https://github.com/c410-f3r/wtx" }
+wtx = { default-features = false, features = ["http2", "optimization", "pool", "tokio", "tokio-rustls", "webpki-roots", "web-socket-handshake"], git = "https://github.com/c410-f3r/wtx" }
 
 [features]
+all-protocols = ["http2", "web-socket"]
 deploy = []
+http2 = []
+web-socket = []
 
 [package]
 edition = "2021"

evaluator/Cargo.toml

@@ -1,12 +1,14 @@
-FROM docker.io/library/rust:1.77-bookworm AS build
+FROM ghcr.io/instrumentisto/rust:beta-bookworm AS build
 ARG IMPLEMENTATION
 COPY . /$IMPLEMENTATION
 WORKDIR /$IMPLEMENTATION
+ENV CARGO_PROFILE_RELEASE_LTO=true
 RUN RUSTFLAGS="-Ccodegen-units=1 -Copt-level=3 -Cpanic=abort -Cstrip=symbols -Ctarget-cpu=native" cargo build --release
 
 FROM docker.io/library/debian:bookworm
 ARG IMPLEMENTATION
 WORKDIR /$IMPLEMENTATION
 COPY --from=build /$IMPLEMENTATION/target/release/$IMPLEMENTATION .
 ENV IMPLEMENTATION ${IMPLEMENTATION}
+ENV RUST_BACKTRACE=1
 CMD ./${IMPLEMENTATION}

evaluator/assets/rust.Dockerfile

@@ -1,50 +1,56 @@
-use crate::{
-    bench_stats::BenchStats, manage_tests, report_line::ReportLine, SOCKET_ADDR, SOCKET_STR,
-};
+use crate::{manage_cases, report_line::ReportLine, SOCKET_ADDR, URI_STR};
 use tokio::net::TcpStream;
 use wtx::{
-    http::{Headers, Method, Request},
-    http2::{ConnectParams, Http2Buffer, Http2Tokio, ReqResBuffer},
-    misc::UriRef,
+    http::Method,
+    http2::{ErrorCode, Http2Buffer, Http2Params, Http2Tokio, ReqResBuffer},
     rng::StaticRng,
 };
 
 pub(crate) async fn bench_all(
     (generic_rp, rps): (ReportLine, &mut Vec<ReportLine>),
 ) -> wtx::Result<()> {
-    macro_rules! name {
-        ($msg_size:expr) => {
-            concat!(
-                connections!(),
-                " connection(s) opening one stream that sends requests of ",
+    macro_rules! case {
+        (($msg_size:expr, $streams:expr), $ex:expr) => {{
+            let name = concat!(
+                http2_connections!(),
+                " connection(s) opening ",
+                $streams,
+                " stream(s) sending requests of ",
                 $msg_size
+            );
+            (
+                name,
+                manage_case!(http2_connections!(), name, generic_rp, $ex),
             )
-        };
+        }};
     }
-
-    manage_tests(
-        generic_rp,
-        rps,
-        [(name!("0B"), manage_bench!(write().await))],
-    );
+    let params = [
+        case!(("64 bytes", 1), write(1, &[4; 64]).await),
+        case!(("64 bytes", 16), write(16, &[4; 64]).await),
+    ];
+    manage_cases(generic_rp, rps, params);
     Ok(())
 }
 
-async fn write() -> wtx::Result<()> {
-    let uri = &UriRef::new(SOCKET_STR);
+async fn write(streams: usize, payload: &[u8]) -> wtx::Result<()> {
     let mut http2 = Http2Tokio::connect(
-        ConnectParams::default(),
-        Http2Buffer::builder(StaticRng::default()).build(),
+        Http2Buffer::new(StaticRng::default()),
+        Http2Params::default(),
         TcpStream::connect(SOCKET_ADDR).await?,
     )
     .await?;
     let rrb = &mut ReqResBuffer::default();
-    let mut stream = http2.stream().await?;
-    let _res = stream
-        .send_req_recv_res(
-            Request::http2(&[], &Headers::new(4096), Method::Get, uri.to_ref()),
-            rrb,
-        )
-        .await;
+    rrb.uri.push_str(URI_STR).unwrap();
+    rrb.data.reserve(payload.len());
+    rrb.data.extend_from_slice(payload).unwrap();
+    for _ in 0..streams {
+        let mut stream = http2.stream().await?;
+        stream
+            .send_req(rrb.as_http2_request_ref(Method::Get))
+            .await?;
+        let _res = stream.recv_res(rrb).await?;
+        stream.send_reset(ErrorCode::NoError).await?;
+    }
+    http2.send_go_away(ErrorCode::NoError).await?;
     Ok(())
 }

evaluator/src/http2.rs

@@ -1,21 +1,38 @@
 #[cfg(feature = "deploy")]
-macro_rules! connections {
+macro_rules! http2_connections {
+    () => {
+        8
+    };
+}
+#[cfg(feature = "deploy")]
+macro_rules! web_socket_connections {
     () => {
         64
     };
 }
+
+#[cfg(not(feature = "deploy"))]
+macro_rules! http2_connections {
+    () => {
+        1
+    };
+}
 #[cfg(not(feature = "deploy"))]
-macro_rules! connections {
+macro_rules! web_socket_connections {
     () => {
         1
     };
 }
 
-macro_rules! manage_bench {
-    ($ex:expr) => {{
-        let mut data = [0.0; connections!()];
+macro_rules! manage_case {
+    ($n:expr, $name:expr, $generic_rp:expr, $ex:expr) => {{
+        println!(
+            "***** Running case '{}' of implementation '{}' of protocol '{}' *****",
+            $name, &$generic_rp.implementation, &$generic_rp.protocol
+        );
+        let mut data = [0.0; $n];
         let mut set = tokio::task::JoinSet::new();
-        for idx in 0..connections!() {
+        for idx in 0..$n {
             let _handle = set.spawn(async move {
                 let now = wtx::misc::GenericTime::now().unwrap();
                 $ex?;
@@ -26,6 +43,6 @@ macro_rules! manage_bench {
             let (idx, value) = rslt.unwrap()?;
             data[idx] = value;
         }
-        BenchStats::new(&data)
+        crate::BenchStats::new(&data)
     }};
 }

evaluator/src/macros.rs

@@ -29,8 +29,8 @@ use tokio::{
     time::sleep,
 };
 use wtx::{
-    http::{Headers, Method, Request},
-    http2::{ConnectParams, Http2Buffer, Http2Tokio, ReqResBuffer},
+    http::Method,
+    http2::{Http2Buffer, Http2Params, Http2Tokio, ReqResBuffer},
     misc::{ArrayString, FnMutFut, GenericTime, TokioRustlsConnector, UriRef},
     rng::StaticRng,
 };
@@ -39,6 +39,7 @@ const _30_DAYS: Duration = Duration::from_secs(30 * 24 * 60 * 60);
 const CSV_HEADER: &str = "environment,protocol,test,implementation,timestamp,min,max,mean,sd\n";
 const SOCKET_ADDR: SocketAddrV4 = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 9000);
 const SOCKET_STR: &str = "127.0.0.1:9000";
+const URI_STR: &str = "http://127.0.0.1:9000";
 
 #[tokio::main]
 async fn main() {
@@ -93,13 +94,28 @@ async fn handle_cmd_output(cmd: &mut Command) {
     );
 }
 
+fn manage_cases(
+    mut generic_rp: ReportLine,
+    rps: &mut Vec<ReportLine>,
+    params: impl IntoIterator<Item = (&'static str, BenchStats)>,
+) {
+    for test_params in params {
+        generic_rp.implementation_specific(test_params);
+        rps.push(generic_rp.clone());
+        generic_rp.implementation_clear();
+    }
+}
+
 async fn manage_prev_csv(curr_timestamp: u64, rps: &mut Vec<ReportLine>) {
     let csv_fun = || async move {
-        let cp = ConnectParams::default();
-        let uri = UriRef::new("https://c410-f3r.github.io:443/wtx-bench/report.csv.gzip");
+        let mut rrb = ReqResBuffer::default();
+        rrb.uri
+            .push_str("https://c410-f3r.github.io:443/wtx-bench/report.csv.gzip")
+            .unwrap();
+        let uri = UriRef::new(&rrb.uri);
         let mut http2 = Http2Tokio::connect(
-            cp,
-            Http2Buffer::builder(StaticRng::default()).build(),
+            Http2Buffer::new(StaticRng::default()),
+            Http2Params::default(),
             TokioRustlsConnector::from_webpki_roots()
                 .http2()
                 .with_tcp_stream(
@@ -109,14 +125,11 @@ async fn manage_prev_csv(curr_timestamp: u64, rps: &mut Vec<ReportLine>) {
                 .await?,
         )
         .await?;
-        let mut rrb = ReqResBuffer::default();
         let mut stream = http2.stream().await?;
-        let res = stream
-            .send_req_recv_res(
-                Request::http2(&[], &Headers::new(4096), Method::Get, uri.to_ref()),
-                &mut rrb,
-            )
+        stream
+            .send_req(rrb.as_http2_request_ref(Method::Get))
             .await?;
+        let res = stream.recv_res(&mut rrb).await?;
         decode_report(res.resource().unwrap().body())
     };
     let Ok(csv) = csv_fun().await else {
@@ -204,26 +217,30 @@ async fn manage_protocols_dir(
         let protocol_name = protocol.file_name().into_string().unwrap();
         match protocol_name.as_str() {
             "http2" => {
-                manage_protocol_dir(
-                    environment,
-                    Protocol::Http2,
-                    &protocol.path(),
-                    rps,
-                    timestamp,
-                    http2::bench_all,
-                )
-                .await
+                if cfg!(feature = "http2") {
+                    manage_protocol_dir(
+                        environment,
+                        Protocol::Http2,
+                        &protocol.path(),
+                        rps,
+                        timestamp,
+                        http2::bench_all,
+                    )
+                    .await
+                }
             }
             "web-socket" => {
-                manage_protocol_dir(
-                    environment,
-                    Protocol::WebSocket,
-                    &protocol.path(),
-                    rps,
-                    timestamp,
-                    web_socket::bench_all,
-                )
-                .await
+                if cfg!(feature = "web-socket") {
+                    manage_protocol_dir(
+                        environment,
+                        Protocol::WebSocket,
+                        &protocol.path(),
+                        rps,
+                        timestamp,
+                        web_socket::bench_all,
+                    )
+                    .await
+                }
             }
             _ => {
                 panic!("'{protocol_name}' is an unknown protocol");
@@ -232,18 +249,6 @@ async fn manage_protocols_dir(
     }
 }
 
-fn manage_tests(
-    mut generic_rp: ReportLine,
-    rps: &mut Vec<ReportLine>,
-    tests_params: impl IntoIterator<Item = (&'static str, BenchStats)>,
-) {
-    for test_params in tests_params {
-        generic_rp.implementation_specific(test_params);
-        rps.push(generic_rp.clone());
-        generic_rp.implementation_clear();
-    }
-}
-
 async fn podman_build(implementation: &str, protocol: Protocol) {
     handle_cmd_output(
         Command::new("podman").args([

evaluator/src/main.rs

@@ -36,7 +36,7 @@ impl ReportLine {
 
     pub(crate) fn implementation_specific(&mut self, (test, bench_stats): (&str, BenchStats)) {
         self.bench_stats = bench_stats;
-        self.test.try_push_str(test).unwrap();
+        self.test.push_str(test).unwrap();
     }
 
     pub(crate) fn push_to_string(&self, string: &mut String) {