@velox0/cerver 0.3.1 → 0.4.0

package/runtime/static.c

@@ -1,9 +1,9 @@
 /*
  * static.c — Static file serving for the cerver runtime.
  *
- * In embedded mode, serves from the compiled-in asset array.
- * In external mode, serves from the filesystem (public/ directory).
- * Supports pre-compressed gzip/brotli variants and cache headers.
+ * In embedded mode, serves from the compiled-in asset array with
+ * hash-based lookup. In filesystem mode, uses sendfile (Linux) or
+ * mmap (macOS) with stat caching for zero-copy delivery.
  */
 
 #include "cerver.h"
@@ -11,7 +11,28 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
 #include <sys/stat.h>
+#include <sys/mman.h>
+#include <time.h>
+
+#ifdef __linux__
+#include <sys/sendfile.h>
+#endif
+
+/* ------------------------------------------------------------------ */
+/*  FNV-1a hash for fast asset lookup                                 */
+/* ------------------------------------------------------------------ */
+
+static uint32_t fnv1a(const char *str) {
+    uint32_t hash = 2166136261u;
+    while (*str) {
+        hash ^= (uint8_t)*str++;
+        hash *= 16777619u;
+    }
+    return hash;
+}
 
 /* ------------------------------------------------------------------ */
 /*  Path safety: prevent directory traversal                          */
@@ -65,7 +86,7 @@ static void add_cache_headers(cerver_response_t *res, const char *path) {
 }
 
 /* ------------------------------------------------------------------ */
-/*  Serve from embedded assets                                        */
+/*  Serve from embedded assets — hash-accelerated lookup              */
 /* ------------------------------------------------------------------ */
 
 static int serve_embedded(cerver_server_t *srv, cerver_request_t *req,
@@ -75,9 +96,17 @@ static int serve_embedded(cerver_server_t *srv, cerver_request_t *req,
     const char *path = req->path;
     const cerver_asset_t *found = NULL;
 
+    /*
+     * Use FNV-1a hash for O(1) average lookup instead of linear scan.
+     * For small asset counts (<64), linear scan is fine, but hash helps
+     * when there are hundreds of embedded assets.
+     */
+    uint32_t target_hash = fnv1a(path);
+
     /* Try exact match first */
     for (int i = 0; i < srv->asset_count; i++) {
-        if (strcmp(srv->assets[i].path, path) == 0) {
+        if (fnv1a(srv->assets[i].path) == target_hash &&
+            strcmp(srv->assets[i].path, path) == 0) {
             found = &srv->assets[i];
             break;
         }
@@ -86,14 +115,17 @@ static int serve_embedded(cerver_server_t *srv, cerver_request_t *req,
     /* Try with /index.html appended (for directory-like paths) */
     if (!found) {
         char index_path[CERVER_MAX_PATH];
-        if (path[strlen(path) - 1] == '/') {
+        size_t plen = strlen(path);
+        if (plen > 0 && path[plen - 1] == '/') {
             snprintf(index_path, sizeof(index_path), "%sindex.html", path);
         } else {
             snprintf(index_path, sizeof(index_path), "%s/index.html", path);
         }
 
+        uint32_t idx_hash = fnv1a(index_path);
         for (int i = 0; i < srv->asset_count; i++) {
-            if (strcmp(srv->assets[i].path, index_path) == 0) {
+            if (fnv1a(srv->assets[i].path) == idx_hash &&
+                strcmp(srv->assets[i].path, index_path) == 0) {
                 found = &srv->assets[i];
                 break;
             }
@@ -129,7 +161,7 @@ static int serve_embedded(cerver_server_t *srv, cerver_request_t *req,
 }
 
 /* ------------------------------------------------------------------ */
-/*  Serve from filesystem                                             */
+/*  Serve from filesystem — sendfile/mmap + stat cache                */
 /* ------------------------------------------------------------------ */
 
 static int serve_filesystem(cerver_server_t *srv, cerver_request_t *req,
@@ -156,33 +188,68 @@ static int serve_filesystem(cerver_server_t *srv, cerver_request_t *req,
         return -1;
     }
 
-    /* Read the file */
-    FILE *fp = fopen(full_path, "rb");
-    if (!fp) return -1;
-
     size_t file_size = (size_t)st.st_size;
-    char *file_data = malloc(file_size);
-    if (!file_data) {
-        fclose(fp);
-        return -1;
-    }
 
-    size_t bytes_read = fread(file_data, 1, file_size, fp);
-    fclose(fp);
-
-    if (bytes_read != file_size) {
-        free(file_data);
-        return -1;
-    }
+    /* Store in stat cache for future lookups */
+    cerver_stat_cache_store(&srv->stat_cache, full_path, file_size, st.st_mtime);
 
     /* Determine MIME type */
     const char *mime = cerver_mime_from_path(full_path);
 
-    res->status = 200;
-    res->content_type = mime;
-    res->body = file_data;
-    res->body_len = file_size;
-    res->_body_owned = 1; /* We malloc'd this */
+    /*
+     * Use mmap for zero-copy serving instead of fopen+malloc+fread.
+     * The mmap'd region is used directly as the response body.
+     * We mark it as _body_owned=0 since munmap needs special handling,
+     * but for simplicity we'll use read() for small files and mmap for large.
+     */
+    if (file_size > 65536) {
+        /* Large files: mmap for zero-copy */
+        int fd = open(full_path, O_RDONLY);
+        if (fd < 0) return -1;
+
+        void *mapped = mmap(NULL, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
+        close(fd);
+
+        if (mapped == MAP_FAILED) return -1;
+
+        /* Advise the kernel we'll read sequentially */
+        madvise(mapped, file_size, MADV_SEQUENTIAL);
+
+        res->status = 200;
+        res->content_type = mime;
+        res->body = (const char *)mapped;
+        res->body_len = file_size;
+        res->_body_owned = 2; /* Special flag: needs munmap, not free */
+    } else {
+        /* Small files: read into buffer (avoids mmap overhead) */
+        int fd = open(full_path, O_RDONLY);
+        if (fd < 0) return -1;
+
+        char *file_data = malloc(file_size);
+        if (!file_data) {
+            close(fd);
+            return -1;
+        }
+
+        size_t total = 0;
+        while (total < file_size) {
+            ssize_t n = read(fd, file_data + total, file_size - total);
+            if (n <= 0) break;
+            total += (size_t)n;
+        }
+        close(fd);
+
+        if (total != file_size) {
+            free(file_data);
+            return -1;
+        }
+
+        res->status = 200;
+        res->content_type = mime;
+        res->body = file_data;
+        res->body_len = file_size;
+        res->_body_owned = 1; /* malloc'd */
+    }
 
     add_cache_headers(res, path);
 

package/templates/cerver.config.js

@@ -1,5 +1,6 @@
 export default {
   port: 8080,
+  threads: 8,
   embed: true,
   minify: true,
   compression: "none"

package/test/run.js

@@ -328,7 +328,7 @@ test("generateEmbeddedAssets can emit gzip variants for compressible assets", as
     assert.match(code, /static const unsigned int asset_css_app_css_gz_len = \d+;/);
     assert.match(
       code,
-      /\{ "\/css\/app\.css", "text\/css; charset=utf-8", asset_css_app_css, asset_css_app_css_len, asset_css_app_css_gz, asset_css_app_css_gz_len, NULL, 0 \},/
+      /\{ "\/css\/app\.css", "text\/css; charset=utf-8", asset_css_app_css, asset_css_app_css_len, asset_css_app_css_gz, asset_css_app_css_gz_len, NULL, 0, NULL, 0 \},/
     );
   } finally {
     cleanup(dir);