results update

Author: MDA2AV

frameworks/actix/Cargo.toml

@@ -11,6 +11,7 @@ rustls-pemfile = "2"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 num_cpus = "1"
+rusqlite = { version = "0.31", features = ["bundled"] }
 
 [profile.release]
 opt-level = 3

frameworks/actix/meta.json

@@ -1,7 +1,7 @@
 {
   "display_name": "actix",
   "language": "Rust",
-  "type": "realistic",
+  "type": "framework",
   "engine": "actix",
   "description": "Actix-web 4 with rustls for HTTP/2 support, compiled with -O3 and thin LTO.",
   "repo": "https://github.com/actix/actix-web",
@@ -13,6 +13,8 @@
     "limited-conn",
     "json",
     "upload",
+    "compression",
+    "mixed",
     "baseline-h2",
     "static-h2"
   ]

frameworks/actix/src/main.rs

@@ -1,10 +1,11 @@
 use actix_web::http::header::{ContentType, HeaderValue, SERVER};
 use actix_web::{web, App, HttpRequest, HttpResponse, HttpServer};
+use rusqlite::Connection;
 use rustls::ServerConfig;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::io;
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 
 static SERVER_HDR: HeaderValue = HeaderValue::from_static("actix");
 
@@ -62,6 +63,8 @@ struct AppState {
     static_files: HashMap<String, StaticFile>,
 }
 
+struct WorkerDb(Mutex<Connection>);
+
 fn load_dataset() -> Vec<DatasetItem> {
     let path = std::env::var("DATASET_PATH").unwrap_or_else(|_| "/data/dataset.json".to_string());
     match std::fs::read_to_string(&path) {
@@ -157,41 +160,11 @@ async fn baseline11_get(req: HttpRequest) -> HttpResponse {
         .body(sum.to_string())
 }
 
-fn crc32_compute(data: &[u8]) -> u32 {
-    static TABLE: std::sync::OnceLock<[[u32; 256]; 8]> = std::sync::OnceLock::new();
-    let t = TABLE.get_or_init(|| {
-        let mut t = [[0u32; 256]; 8];
-        for i in 0..256u32 {
-            let mut c = i;
-            for _ in 0..8 { c = if c & 1 != 0 { 0xEDB88320 ^ (c >> 1) } else { c >> 1 }; }
-            t[0][i as usize] = c;
-        }
-        for i in 0..256 {
-            for s in 1..8 { t[s][i] = (t[s-1][i] >> 8) ^ t[0][(t[s-1][i] & 0xFF) as usize]; }
-        }
-        t
-    });
-    let mut crc = 0xFFFFFFFFu32;
-    let mut i = 0;
-    while i + 8 <= data.len() {
-        let a = u32::from_le_bytes([data[i], data[i+1], data[i+2], data[i+3]]) ^ crc;
-        let b = u32::from_le_bytes([data[i+4], data[i+5], data[i+6], data[i+7]]);
-        crc = t[7][(a & 0xFF) as usize] ^ t[6][((a >> 8) & 0xFF) as usize]
-            ^ t[5][((a >> 16) & 0xFF) as usize] ^ t[4][(a >> 24) as usize]
-            ^ t[3][(b & 0xFF) as usize] ^ t[2][((b >> 8) & 0xFF) as usize]
-            ^ t[1][((b >> 16) & 0xFF) as usize] ^ t[0][(b >> 24) as usize];
-        i += 8;
-    }
-    while i < data.len() { crc = (crc >> 8) ^ t[0][((crc ^ data[i] as u32) & 0xFF) as usize]; i += 1; }
-    crc ^ 0xFFFFFFFF
-}
-
 async fn upload(body: web::Bytes) -> HttpResponse {
-    let crc = crc32_compute(&body);
     HttpResponse::Ok()
         .insert_header((SERVER, SERVER_HDR.clone()))
         .content_type(ContentType::plaintext())
-        .body(format!("{:08x}", crc))
+        .body(body.len().to_string())
 }
 
 async fn baseline11_post(req: HttpRequest, body: web::Bytes) -> HttpResponse {
@@ -253,6 +226,43 @@ async fn compression(state: web::Data<Arc<AppState>>) -> HttpResponse {
         .body(state.json_large_cache.clone())
 }
 
+async fn db_endpoint(req: HttpRequest, db: web::Data<WorkerDb>) -> HttpResponse {
+    let min: f64 = req.uri().query().and_then(|q| {
+        q.split('&').find_map(|p| p.strip_prefix("min=").and_then(|v| v.parse().ok()))
+    }).unwrap_or(10.0);
+    let max: f64 = req.uri().query().and_then(|q| {
+        q.split('&').find_map(|p| p.strip_prefix("max=").and_then(|v| v.parse().ok()))
+    }).unwrap_or(50.0);
+    let conn = db.0.lock().unwrap();
+    let mut stmt = conn.prepare_cached(
+        "SELECT id, name, category, price, quantity, active, tags, rating_score, rating_count FROM items WHERE price BETWEEN ?1 AND ?2 LIMIT 50"
+    ).unwrap();
+    let rows = stmt.query_map(rusqlite::params![min, max], |row| {
+        Ok(serde_json::json!({
+            "id": row.get::<_, i64>(0)?,
+            "name": row.get::<_, String>(1)?,
+            "category": row.get::<_, String>(2)?,
+            "price": row.get::<_, f64>(3)?,
+            "quantity": row.get::<_, i64>(4)?,
+            "active": row.get::<_, i64>(5)? == 1,
+            "tags": serde_json::from_str::<serde_json::Value>(&row.get::<_, String>(6)?).unwrap_or_default(),
+            "rating": serde_json::json!({
+                "score": row.get::<_, f64>(7)?,
+                "count": row.get::<_, i64>(8)?
+            })
+        }))
+    });
+    let items: Vec<serde_json::Value> = match rows {
+        Ok(mapped) => mapped.filter_map(|r| r.ok()).collect(),
+        Err(_) => Vec::new(),
+    };
+    let result = serde_json::json!({"items": items, "count": items.len()});
+    HttpResponse::Ok()
+        .insert_header((SERVER, SERVER_HDR.clone()))
+        .content_type(ContentType::json())
+        .body(result.to_string())
+}
+
 async fn static_file(
     state: web::Data<Arc<AppState>>,
     path: web::Path<String>,
@@ -307,16 +317,27 @@ async fn main() -> io::Result<()> {
     let mut server = HttpServer::new({
         let state = state.clone();
         move || {
+            let worker_db = Connection::open_with_flags(
+                "/data/benchmark.db",
+                rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY,
+            )
+            .map(|conn| {
+                conn.execute_batch("PRAGMA mmap_size=268435456").ok();
+                WorkerDb(Mutex::new(conn))
+            })
+            .expect("Failed to open database");
             App::new()
                 .wrap(actix_web::middleware::Compress::default())
                 .app_data(web::Data::new(state.clone()))
+                .app_data(web::Data::new(worker_db))
                 .app_data(web::PayloadConfig::new(25 * 1024 * 1024))
                 .route("/pipeline", web::get().to(pipeline))
                 .route("/baseline11", web::get().to(baseline11_get))
                 .route("/baseline11", web::post().to(baseline11_post))
                 .route("/baseline2", web::get().to(baseline2))
                 .route("/json", web::get().to(json_endpoint))
                 .route("/compression", web::get().to(compression))
+                .route("/db", web::get().to(db_endpoint))
                 .route("/upload", web::post().to(upload))
                 .route("/static/{filename}", web::get().to(static_file))
         }

frameworks/aspnet-minimal/Program.cs

@@ -197,8 +197,7 @@
 {
     using var ms = new MemoryStream();
     await req.Body.CopyToAsync(ms);
-    uint crc = Crc32Helper.Compute(ms.GetBuffer().AsSpan(0, (int)ms.Length));
-    return Results.Text(crc.ToString("x8"));
+    return Results.Text(ms.Length.ToString());
 });
 
 app.MapGet("/json", () =>
@@ -278,40 +277,3 @@ class RatingInfo
     public double Score { get; set; }
     public int Count { get; set; }
 }
-
-static class Crc32Helper
-{
-    private static readonly uint[][] T = new uint[8][];
-    static Crc32Helper()
-    {
-        for (int s = 0; s < 8; s++) T[s] = new uint[256];
-        for (uint i = 0; i < 256; i++)
-        {
-            uint c = i;
-            for (int j = 0; j < 8; j++)
-                c = (c >> 1) ^ (0xEDB88320u & (0u - (c & 1u)));
-            T[0][i] = c;
-        }
-        for (uint i = 0; i < 256; i++)
-            for (int s = 1; s < 8; s++)
-                T[s][i] = (T[s-1][i] >> 8) ^ T[0][T[s-1][i] & 0xFF];
-    }
-    public static uint Compute(ReadOnlySpan<byte> data)
-    {
-        uint crc = 0xFFFFFFFF;
-        int i = 0;
-        while (i + 8 <= data.Length)
-        {
-            uint a = (uint)(data[i] | (data[i+1] << 8) | (data[i+2] << 16) | (data[i+3] << 24)) ^ crc;
-            uint b = (uint)(data[i+4] | (data[i+5] << 8) | (data[i+6] << 16) | (data[i+7] << 24));
-            crc = T[7][a & 0xFF] ^ T[6][(a >> 8) & 0xFF]
-                ^ T[5][(a >> 16) & 0xFF] ^ T[4][a >> 24]
-                ^ T[3][b & 0xFF] ^ T[2][(b >> 8) & 0xFF]
-                ^ T[1][(b >> 16) & 0xFF] ^ T[0][b >> 24];
-            i += 8;
-        }
-        while (i < data.Length)
-            crc = (crc >> 8) ^ T[0][(crc ^ data[i++]) & 0xFF];
-        return crc ^ 0xFFFFFFFF;
-    }
-}

frameworks/aspnet-minimal/meta.json

@@ -1,7 +1,7 @@
 {
   "display_name": "aspnet-minimal",
   "language": "C#",
-  "type": "realistic",
+  "type": "framework",
   "engine": "Kestrel",
   "description": "Minimal ASP.NET Core server using .NET 10 preview with Kestrel and minimal API routing.",
   "repo": "https://github.com/dotnet/aspnetcore",

frameworks/bun/meta.json

@@ -1,7 +1,7 @@
 {
   "display_name": "bun",
   "language": "TS",
-  "type": "realistic",
+  "type": "framework",
   "engine": "JSC",
   "description": "Bun's built-in HTTP server using JavaScriptCore engine with multi-core clustering.",
   "repo": "https://github.com/oven-sh/bun",

frameworks/bun/server.ts

@@ -144,9 +144,7 @@ function handleRequest(req: Request): Response | Promise<Response> {
 
   if (path === "/upload" && req.method === "POST") {
     return req.arrayBuffer().then((ab) => {
-      const buf = Buffer.from(ab);
-      const c = zlib.crc32(buf);
-      return new Response((c >>> 0).toString(16).padStart(8, "0"), {
+      return new Response(String(ab.byteLength), {
         headers: { "content-type": "text/plain" },
       });
     });

frameworks/caddy/handler.go

@@ -4,7 +4,6 @@ import (
 	"database/sql"
 	"encoding/json"
 	"fmt"
-	"hash/crc32"
 	"io"
 	"math"
 	"net/http"
@@ -220,10 +219,9 @@ func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request, next caddyht
 	case "/upload":
 		if r.Method == "POST" && r.Body != nil {
 			body, _ := io.ReadAll(r.Body)
-			checksum := crc32.ChecksumIEEE(body)
 			w.Header().Set("Content-Type", "text/plain")
 			w.Header().Set("Server", "caddy")
-			fmt.Fprintf(w, "%08x", checksum)
+			fmt.Fprintf(w, "%d", len(body))
 		} else {
 			http.Error(w, "POST required", 405)
 		}

frameworks/caddy/meta.json

@@ -1,7 +1,7 @@
 {
   "display_name": "caddy",
   "language": "Go",
-  "type": "realistic",
+  "type": "framework",
   "engine": "caddy",
   "description": "Caddy web server with a custom handler module for benchmark endpoints, native HTTP/2 support.",
   "repo": "https://github.com/caddyserver/caddy",

frameworks/deno/Dockerfile

@@ -1,6 +1,9 @@
 FROM denoland/deno:2.2.2
+RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates curl && rm -rf /var/lib/apt/lists/*
 WORKDIR /app
 COPY main.ts .
 RUN deno cache main.ts
+RUN curl -fsSL -o /app/libsqlite3.so https://github.com/denodrivers/sqlite3/releases/download/0.12.0/libsqlite3.so
+ENV DENO_SQLITE_PATH=/app/libsqlite3.so
 EXPOSE 8080
 CMD ["deno", "serve", "--parallel", "--port", "8080", "--host", "0.0.0.0", "-A", "main.ts"]