New test - CRUD

Author: MDA2AV

CHANGELOG.md

@@ -4,6 +4,18 @@ Notable changes to test profiles, scoring, and validation.
 
 ## 2026-04-16
 
+### CRUD — realistic REST API benchmark (H/1.1 Isolated)
+
+New `crud` profile that benchmarks a realistic REST API with four operations: paginated list, cached single-item read, create, and update.
+
+**Workload mix:** 40% paginated list queries (two SQL queries each: data + count), 30% single-item reads (in-process cached with 1s TTL), 15% creates (INSERT with ON CONFLICT upsert), 15% updates (UPDATE + cache invalidation). Uses gcannon's `{RAND:min:max}` and `{SEQ:start}` placeholders for realistic per-request ID distribution — GET reads randomize across 50K items, POST creates use auto-incrementing IDs starting at 100K, PUT updates randomize across the existing 50K range.
+
+**Cache-aside pattern:** Single-item reads use `IMemoryCache` (or equivalent) with 1s absolute expiration. First request returns `X-Cache: MISS`, subsequent requests within the TTL return `X-Cache: HIT`. PUT invalidates the cache entry, so the next read is a fresh DB query.
+
+**Connections:** 512, 4,096. **CPU:** 64 threads (cores 0-31, 64-95). **Duration:** 10s per run, best of 3.
+
+**Validation:** 7 checks — list pagination (count, total, page, rating structure), single-item read, cache-aside MISS→HIT sequence, 404 for missing items, POST 201 Created, read-back of created item, PUT with cache invalidation verification.
+
 ### Production Stack — JWT auth, HybridCache, 10K-item CRUD
 
 Major rework of the `production-stack` profile. The test now models a realistic CRUD API with stateless JWT authentication, a three-tier cache hierarchy under real pressure, and concurrent read+write load.

data/pgdb-seed.sql

@@ -100016,6 +100016,10 @@ COPY items (id, name, category, price, quantity, active, tags, rating_score, rat
 
 -- Verify: SELECT COUNT(*) FROM items; -- should return 100000
 
+-- Sequence for CRUD test POST inserts. Starts above the seeded range
+-- so explicit-ID inserts don't collide with seeded rows.
+CREATE SEQUENCE IF NOT EXISTS items_id_seq START 100001;
+
 -- ── production-stack users table ────────────────────────────────────────────
 -- Used by the /api/me cache-aside path. Four seed rows matching the four
 -- sessions pre-seeded in data/redis-seed.txt (bench-session-001..004 map

docker/gcannon.Dockerfile

@@ -1,12 +1,18 @@
 FROM ubuntu:24.04 AS build
 ARG GCANNON_REF=main
+# CACHE_BUST is set to the current timestamp by the benchmark script so
+# docker always pulls the latest gcannon source instead of reusing a
+# stale git-clone layer. Without this, edits pushed to the gcannon repo
+# are invisible until the user manually runs --no-cache.
+ARG CACHE_BUST=0
 RUN apt-get update && apt-get install -y --no-install-recommends \
         gcc make git ca-certificates && rm -rf /var/lib/apt/lists/*
 WORKDIR /deps
 RUN git clone --branch liburing-2.9 --depth 1 https://github.com/axboe/liburing.git && \
     cd liburing && ./configure --prefix=/usr && make -j"$(nproc)" -C src && make install -C src
 WORKDIR /build
-RUN git clone https://github.com/MDA2AV/gcannon . && \
+RUN echo "cache_bust=$CACHE_BUST" && \
+    git clone https://github.com/MDA2AV/gcannon . && \
     git checkout "$GCANNON_REF" && \
     make clean && make -j"$(nproc)"
 

frameworks/aspnet-minimal/Handlers.cs

@@ -2,6 +2,7 @@
 using System.Buffers;
 using System.Text.Json.Serialization;
 using Microsoft.AspNetCore.Http.HttpResults;
+using Microsoft.Extensions.Caching.Memory;
 
 
 [JsonSerializable(typeof(ResponseDto<ProcessedItem>))]
@@ -120,4 +121,161 @@ public static async Task<Results<JsonHttpResult<ResponseDto<DbResponseItemDto>>,
 
         return TypedResults.Json(new ResponseDto<DbResponseItemDto>(items, items.Count), AppJsonContext.Default.ResponseDtoDbResponseItemDto);
     }
-}
+
+    // ── CRUD handlers ──────────────────────────────────────────────────
+    //
+    // Realistic REST API with paginated list, cached single-item read,
+    // create, and update. In-process IMemoryCache with 1s TTL on single-
+    // item reads, invalidated on PUT. List queries always hit Postgres
+    // (two queries: data + count).
+
+    private static readonly MemoryCacheEntryOptions _crudCacheOpts =
+        new() { AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(1) };
+
+    private static readonly JsonSerializerOptions _crudJsonOpts =
+        new(JsonSerializerDefaults.Web);
+
+    // GET /crud/items?category=X&page=N&limit=M — paginated list (always DB, never cached)
+    public static async Task<IResult> CrudList(HttpRequest req)
+    {
+        if (AppData.PgDataSource is null)
+            return TypedResults.Problem("DB not available");
+
+        var query = req.Query;
+        var category = query["category"].ToString();
+        if (string.IsNullOrEmpty(category)) category = "electronics";
+        int.TryParse(query["page"], out var page);
+        if (page < 1) page = 1;
+        int.TryParse(query["limit"], out var limit);
+        if (limit < 1 || limit > 50) limit = 10;
+        var offset = (page - 1) * limit;
+
+        // Query 1: data
+        await using var cmd = AppData.PgDataSource.CreateCommand(
+            "SELECT id, name, category, price, quantity, active, tags, rating_score, rating_count " +
+            "FROM items WHERE category = $1 ORDER BY id LIMIT $2 OFFSET $3");
+        cmd.Parameters.AddWithValue(category);
+        cmd.Parameters.AddWithValue(limit);
+        cmd.Parameters.AddWithValue(offset);
+
+        await using var reader = await cmd.ExecuteReaderAsync();
+        var items = new List<object>();
+        while (await reader.ReadAsync())
+        {
+            items.Add(new
+            {
+                id       = reader.GetInt32(0),
+                name     = reader.GetString(1),
+                category = reader.GetString(2),
+                price    = reader.GetInt32(3),
+                quantity = reader.GetInt32(4),
+                active   = reader.GetBoolean(5),
+                tags     = JsonSerializer.Deserialize<List<string>>(reader.GetString(6), AppJsonContext.Default.ListString)!,
+                rating   = new RatingInfo { Score = (int)reader.GetDouble(7), Count = reader.GetInt32(8) }
+            });
+        }
+        await reader.CloseAsync();
+
+        // Query 2: total count
+        await using var countCmd = AppData.PgDataSource.CreateCommand(
+            "SELECT COUNT(*) FROM items WHERE category = $1");
+        countCmd.Parameters.AddWithValue(category);
+        var total = (long)(await countCmd.ExecuteScalarAsync())!;
+
+        return TypedResults.Ok(new { items, total, page, limit });
+    }
+
+    // GET /crud/items/{id} — single item, cached with 1s TTL
+    public static async Task<IResult> CrudRead(int id, IMemoryCache cache, HttpContext ctx)
+    {
+        if (AppData.PgDataSource is null)
+            return TypedResults.Problem("DB not available");
+
+        var cacheKey = $"crud:{id}";
+        if (cache.TryGetValue(cacheKey, out object? cached))
+        {
+            ctx.Response.Headers["X-Cache"] = "HIT";
+            return TypedResults.Ok(cached);
+        }
+
+        await using var cmd = AppData.PgDataSource.CreateCommand(
+            "SELECT id, name, category, price, quantity, active, tags, rating_score, rating_count " +
+            "FROM items WHERE id = $1 LIMIT 1");
+        cmd.Parameters.AddWithValue(id);
+
+        await using var reader = await cmd.ExecuteReaderAsync();
+        if (!await reader.ReadAsync())
+            return TypedResults.NotFound();
+
+        var item = new
+        {
+            id       = reader.GetInt32(0),
+            name     = reader.GetString(1),
+            category = reader.GetString(2),
+            price    = reader.GetInt32(3),
+            quantity = reader.GetInt32(4),
+            active   = reader.GetBoolean(5),
+            tags     = JsonSerializer.Deserialize<List<string>>(reader.GetString(6), AppJsonContext.Default.ListString)!,
+            rating   = new RatingInfo { Score = (int)reader.GetDouble(7), Count = reader.GetInt32(8) }
+        };
+
+        cache.Set(cacheKey, item, _crudCacheOpts);
+        ctx.Response.Headers["X-Cache"] = "MISS";
+        return TypedResults.Ok(item);
+    }
+
+    // POST /crud/items — create item, return 201
+    public static async Task<IResult> CrudCreate(HttpRequest req)
+    {
+        if (AppData.PgDataSource is null)
+            return TypedResults.Problem("DB not available");
+
+        using var sr = new StreamReader(req.Body);
+        var body = await sr.ReadToEndAsync();
+        var input = JsonSerializer.Deserialize<CrudItemInput>(body, _crudJsonOpts);
+        if (input is null)
+            return TypedResults.BadRequest();
+
+        await using var cmd = AppData.PgDataSource.CreateCommand(
+            "INSERT INTO items (id, name, category, price, quantity, active, tags, rating_score, rating_count) " +
+            "VALUES ($1, $2, $3, $4, $5, true, '[\"bench\"]', 0, 0) " +
+            "ON CONFLICT (id) DO UPDATE SET name = $2, price = $4, quantity = $5 " +
+            "RETURNING id");
+        cmd.Parameters.AddWithValue(input.Id);
+        cmd.Parameters.AddWithValue(input.Name ?? "New Product");
+        cmd.Parameters.AddWithValue(input.Category ?? "test");
+        cmd.Parameters.AddWithValue(input.Price);
+        cmd.Parameters.AddWithValue(input.Quantity);
+
+        var newId = (int)(await cmd.ExecuteScalarAsync())!;
+        return TypedResults.Created($"/crud/items/{newId}", new { id = newId, name = input.Name, category = input.Category, price = input.Price, quantity = input.Quantity });
+    }
+
+    // PUT /crud/items/{id} — update item, invalidate cache
+    public static async Task<IResult> CrudUpdate(int id, HttpRequest req, IMemoryCache cache)
+    {
+        if (AppData.PgDataSource is null)
+            return TypedResults.Problem("DB not available");
+
+        using var sr = new StreamReader(req.Body);
+        var body = await sr.ReadToEndAsync();
+        var input = JsonSerializer.Deserialize<CrudItemInput>(body, _crudJsonOpts);
+        if (input is null)
+            return TypedResults.BadRequest();
+
+        await using var cmd = AppData.PgDataSource.CreateCommand(
+            "UPDATE items SET name = $1, price = $2, quantity = $3 WHERE id = $4");
+        cmd.Parameters.AddWithValue(input.Name ?? "Updated");
+        cmd.Parameters.AddWithValue(input.Price);
+        cmd.Parameters.AddWithValue(input.Quantity);
+        cmd.Parameters.AddWithValue(id);
+
+        var affected = await cmd.ExecuteNonQueryAsync();
+        if (affected == 0) return TypedResults.NotFound();
+
+        cache.Remove($"crud:{id}");
+        return TypedResults.Ok(new { id, name = input.Name, price = input.Price, quantity = input.Quantity });
+    }
+}
+
+record CrudItemInput(int Id, string? Name, string? Category, int Price, int Quantity);

frameworks/aspnet-minimal/Program.cs

@@ -2,9 +2,11 @@
 
 using Microsoft.AspNetCore.Server.Kestrel.Core;
 using Microsoft.AspNetCore.StaticFiles;
+using Microsoft.Extensions.Caching.Memory;
 
 var builder = WebApplication.CreateBuilder(args);
 builder.Logging.ClearProviders();
+builder.Services.AddMemoryCache();
 
 var certPath = Environment.GetEnvironmentVariable("TLS_CERT") ?? "/certs/server.crt";
 var keyPath = Environment.GetEnvironmentVariable("TLS_KEY") ?? "/certs/server.key";
@@ -64,6 +66,15 @@
 app.MapGet("/json/{count}", Handlers.Json);
 app.MapGet("/async-db", Handlers.AsyncDatabase);
 
+// ── CRUD endpoints ─────────────────────────────────────────────────────────
+// Realistic REST API: paginated list, cached single-item read, create, update.
+// In-process IMemoryCache with 1s TTL on single-item reads, invalidated on PUT.
+
+app.MapGet("/crud/items", Handlers.CrudList);
+app.MapGet("/crud/items/{id:int}", Handlers.CrudRead);
+app.MapPost("/crud/items", Handlers.CrudCreate);
+app.MapPut("/crud/items/{id:int}", Handlers.CrudUpdate);
+
 app.MapStaticAssets();
 
 app.Run();

frameworks/aspnet-minimal/README.md

@@ -20,6 +20,10 @@ Minimal ASP.NET Core HTTP server using .NET 10 with Kestrel and minimal API rout
 | `/json/{count}` | GET | Returns `count` items from the preloaded dataset; honors `Accept-Encoding: gzip/br/deflate` for the `json-comp` profile |
 | `/async-db` | GET | Postgres range query: `SELECT ... WHERE price BETWEEN $min AND $max LIMIT $limit` |
 | `/upload` | POST | Streams the request body and returns the byte count |
+| `/crud/items` | GET | Paginated list by category with two queries (data + count) |
+| `/crud/items/{id}` | GET | Single item read with `IMemoryCache` (1s TTL), returns `X-Cache: HIT/MISS` |
+| `/crud/items` | POST | Create item via INSERT with ON CONFLICT upsert, returns 201 |
+| `/crud/items/{id}` | PUT | Update item and invalidate cache entry |
 | `/static/*` | GET | Serves files from `/data/static` via `MapStaticAssets` with precomputed ETags + compression |
 
 ## Notes

frameworks/aspnet-minimal/meta.json

@@ -18,6 +18,7 @@
     "api-16",
     "static",
     "async-db",
+    "crud",
     "baseline-h2",
     "static-h2",
     "baseline-h3",

requests/crud-create-1.raw

@@ -0,0 +1,6 @@
+POST /crud/items HTTP/1.1
+Host: localhost:8080
+Content-Type: application/json
+Content-Length: 78
+
+{"id":{SEQ:100001},"name":"New Product","category":"test","price":150,"quantity":30}

requests/crud-create-2.raw

@@ -0,0 +1,6 @@
+POST /crud/items HTTP/1.1
+Host: localhost:8080
+Content-Type: application/json
+Content-Length: 78
+
+{"id":{SEQ:100001},"name":"New Product","category":"test","price":150,"quantity":30}

requests/crud-create-3.raw

@@ -0,0 +1,6 @@
+POST /crud/items HTTP/1.1
+Host: localhost:8080
+Content-Type: application/json
+Content-Length: 78
+
+{"id":{SEQ:100001},"name":"New Product","category":"test","price":150,"quantity":30}