dm-framework: 1.0.2

dm-framework/Makefile

@@ -5,7 +5,7 @@
 include $(TOPDIR)/rules.mk
 
 PKG_NAME:=dm-framework
-PKG_VERSION:=1.0.1
+PKG_VERSION:=1.0.2
 PKG_RELEASE:=1
 
 USE_LOCAL:=0

dm-framework/dmf_service.json

@@ -13,10 +13,10 @@
       "loglevel": "3"
     },
     "apply_handler": {
-      "uci": [
+      "dmmap": [
         {
           "file": [
-            "/etc/bbfdm/dmmap/Bridging"
+            "Bridging"
           ],
           "external_handler": "/etc/dm-framework/dmf_reload_handler.sh"
         }

dmcli/Makefile

@@ -11,12 +11,12 @@ include $(TOPDIR)/rules.mk
 
 PKG_NAME:=dmcli
 PKG_LICENSE:=PROPRIETARY GENEXIS
-PKG_VERSION:=1.9.7
+PKG_VERSION:=1.9.8
 PKG_RELEASE:=1
 
 PKG_SOURCE_PROTO:=git
 PKG_SOURCE_URL:=https://dev.iopsys.eu/gnx/dmcli.git
-PKG_SOURCE_VERSION:=60debf1f94ed1dddcaa2e079071f5a65db8f3041
+PKG_SOURCE_VERSION:=dd9b092c67041345e0b72ae19a5b6a199ed39e3e
 PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION)-$(PKG_SOURCE_VERSION).tar.xz
 PKG_MIRROR_HASH:=skip
 

fluent-bit/Makefile

@@ -1,21 +1,13 @@
-#
-# Copyright (C) 2024-2025 IOPSYS
-#
-
 include $(TOPDIR)/rules.mk
 
 PKG_NAME:=fluent-bit
-PKG_VERSION:=4.0.4
-PKG_RELEASE:=$(AUTORELEASE)
+PKG_VERSION:=4.2.0
+PKG_RELEASE:=1
 
-LOCAL_DEV:=0
-ifneq ($(LOCAL_DEV),1)
 PKG_SOURCE_PROTO:=git
 PKG_SOURCE_URL:=https://github.com/fluent/fluent-bit.git
 PKG_SOURCE_VERSION=v$(PKG_VERSION)
-PKG_SOURCE:=$(PKG_NAME)-v$(PKG_VERSION).tar.zst
-PKG_MIRROR_HASH:=skip
-endif
+PKG_MIRROR_HASH:=cad2d94cf7a720a3910c781f80187e2c399aa8acbfa1046aa7445a4d1495fafd
 
 PKG_LICENSE:=Apache-2.0
 PKG_LICENSE_FILES:=LICENSE
@@ -24,52 +16,55 @@ include $(INCLUDE_DIR)/package.mk
 include $(INCLUDE_DIR)/cmake.mk
 
 define Package/fluent-bit
-	CATEGORY:=Utilities
-	DEPENDS:= +libyaml +libopenssl +libcurl +libatomic +musl-fts +flex +bison +libstdcpp +@OPENSSL_WITH_NPN
-	TITLE:=Fluent-Bit
-	URL:=https://fluentbit.io/
+  SECTION:=admin
+  CATEGORY:=Administration
+  TITLE:=Fast and Lightweight Logs and Metrics processor
+  URL:=https://fluentbit.io/
+  DEPENDS:= +libyaml +libopenssl +libcurl +libstdcpp +libatomic +musl-fts +flex +bison \
+	    +libsasl2 +@OPENSSL_WITH_NPN
 endef
 
 define Package/fluent-bit/description
-	Fluent Bit is a super fast, lightweight, and highly scalable logging and metrics processor and forwarder.
+  Fluent Bit is a super fast, lightweight, and highly scalable logging
+  and metrics processor and forwarder.
 endef
 
-ifeq ($(LOCAL_DEV),1)
-define Build/Prepare
-        $(CP) -rf ./fluent-bit/* $(PKG_BUILD_DIR)/
+define Package/fluent-bit/conffiles
+/etc/fluent-bit/parsers.conf
 endef
-endif
 
-# General options
 TARGET_LDFLAGS +=-lfts -latomic
 
 CMAKE_OPTIONS+= \
 	-DFLB_RELEASE=Yes \
-	-DFLB_SMALL=No \
 	-DEXCLUDE_FROM_ALL=true \
-	-DFLB_SHARED_LIB=Yes \
-	-DFLB_DEBUG=Yes \
-	-DFLB_ALL=No \
-	-DFLB_JEMALLOC=No \
 	-DFLB_EXAMPLES=No \
 	-DFLB_CHUNK_TRACE=No \
 	-DFLB_BACKTRACE=No \
-	-DFLB_KAFKA=No \
 	-DFLB_WASM=No \
-	-DFLB_LUAJIT=Yes
+	-DFLB_LUAJIT=Yes \
+	-DWITH_SASL=No \
+	-DWITH_ZLIB=No \
+	-DWITH_ZSTD=No
+
+CMAKE_OPTIONS += \
+	-DFLB_SMALL=Yes \
+	-DFLB_ALL=No \
+	-DFLB_DEBUG=Yes \
+	-DFLB_JEMALLOC=No \
+	-DFLB_KAFKA=No
 
-# In plugins
 CMAKE_OPTIONS += \
 	-DFLB_IN_SYSLOG=Yes \
 	-DFLB_IN_CPU=Yes \
 	-DFLB_IN_MEM=Yes \
 	-DFLB_IN_DISK=Yes \
-	-DFLB_IN_EXEC=Yes \
 	-DFLB_IN_HEAD=Yes \
 	-DFLB_IN_KMSG=Yes \
 	-DFLB_IN_TAIL=Yes \
-	-DFLB_IN_FORWARD=No \
 	-DFLB_IN_PROC=No \
+	-DFLB_IN_EXEC=No \
+	-DFLB_IN_FORWARD=No \
 	-DFLB_IN_RANDOM=No \
 	-DFLB_IN_SERIAL=No \
 	-DFLB_IN_MQTT=No \
@@ -85,7 +80,6 @@ CMAKE_OPTIONS += \
 	-DFLB_IN_KUBERNETES_EVENTS=No \
 	-DFLB_IN_KAFKA=No \
 	-DFLB_IN_LIB=No \
-	-DFLB_IN_SYSTEMD=No \
 	-DFLB_IN_DUMMY=No \
 	-DFLB_IN_NETIF=No \
 	-DFLB_IN_COLLECTD=No \
@@ -96,18 +90,18 @@ CMAKE_OPTIONS += \
 	-DFLB_IN_OPENTELEMETRY=No \
 	-DFLB_IN_ELASTICSEARCH=No \
 	-DFLB_IN_CALYPTIA_FLEET=No \
-	-DFLB_IN_SPLUNK=No
+	-DFLB_IN_SPLUNK=No \
 	-DFLB_IN_HEALTH=No \
 	-DFLB_IN_WINLOG=No \
 	-DFLB_IN_WINEVTLOG=No
 
-
-# Filter options
 CMAKE_OPTIONS += \
+	-DFLB_FILTER_LUA=Yes \
+	-DFLB_FILTER_SYSINFO=Yes \
+	-DFLB_FILTER_MODIFY=Yes \
 	-DFLB_FILTER_AWS=No \
 	-DFLB_FILTER_ECS=No \
 	-DFLB_FILTER_KUBERNETES=No \
-	-DFLB_FILTER_LUA=Yes \
 	-DFLB_FILTER_NEST=No \
 	-DFLB_FILTER_RECORD_MODIFIER=No \
 	-DFLB_FILTER_THROTTLE=No \
@@ -117,10 +111,8 @@ CMAKE_OPTIONS += \
 	-DFLB_FILTER_GEOIP2=No \
 	-DFLB_FILTER_NIGHTFALL=No
 
-# out plugins
 CMAKE_OPTIONS += \
 	-DFLB_OUT_EXIT=Yes \
-	-DFLB_OUT_FORWARD=Yes \
 	-DFLB_OUT_HTTP=Yes \
 	-DFLB_OUT_NATS=Yes \
 	-DFLB_OUT_TCP=Yes \
@@ -129,6 +121,7 @@ CMAKE_OPTIONS += \
 	-DFLB_OUT_STDOUT=Yes \
 	-DFLB_OUT_SYSLOG=Yes \
 	-DFLB_OUT_NULL=Yes \
+	-DFLB_OUT_FORWARD=No \
 	-DFLB_OUT_PLOT=No \
 	-DFLB_OUT_AZURE=No \
 	-DFLB_OUT_AZURE_BLOB=No \
@@ -142,6 +135,7 @@ CMAKE_OPTIONS += \
 	-DFLB_OUT_GELF=No \
 	-DFLB_OUT_INFLUXDB=No \
 	-DFLB_OUT_KAFKA=No \
+	-DFLB_OUT_KAFKA_REST=No \
 	-DFLB_OUT_NRLOGS=No \
 	-DFLB_OUT_OPENSEARCH=No \
 	-DFLB_OUT_TD=No \
@@ -153,8 +147,6 @@ CMAKE_OPTIONS += \
 	-DFLB_OUT_FLOWCOUNTER=No \
 	-DFLB_OUT_LOGDNA=No \
 	-DFLB_OUT_LOKI=No \
-	-DFLB_OUT_KAFKA=No \
-	-DFLB_OUT_KAFKA_REST=No \
 	-DFLB_OUT_CLOUDWATCH_LOGS=No \
 	-DFLB_OUT_KINESIS_FIREHOSE=No \
 	-DFLB_OUT_KINESIS_STREAMS=No \
@@ -170,11 +162,10 @@ CMAKE_OPTIONS += \
 
 define Package/fluent-bit/install
 	$(INSTALL_DIR) $(1)/usr/sbin
-	$(INSTALL_DIR) $(1)/etc/fluent-bit
-	$(INSTALL_DIR) $(1)/etc/fluent-bit/conf.d
 	$(INSTALL_BIN) $(PKG_BUILD_DIR)/bin/fluent-bit $(1)/usr/sbin/
-	$(INSTALL_DATA) ./files/fluent-bit.conf $(1)/etc/fluent-bit/fluent-bit.conf
-	$(INSTALL_DATA) $(PKG_BUILD_DIR)/conf/parsers.conf $(1)/etc/fluent-bit/parsers.conf
+
+	$(INSTALL_DIR) $(1)/etc/fluent-bit
+	$(INSTALL_CONF) $(PKG_BUILD_DIR)/conf/parsers.conf $(1)/etc/fluent-bit/parsers.conf
 endef
 
 $(eval $(call BuildPackage,fluent-bit))

fluent-bit/patches/0020-fix_kmsg.patch

@@ -1,5 +1,5 @@
 diff --git a/plugins/in_kmsg/in_kmsg.c b/plugins/in_kmsg/in_kmsg.c
-index cd5c4cd17..15f105451 100644
+index fe372a9a2..6acb34893 100644
 --- a/plugins/in_kmsg/in_kmsg.c
 +++ b/plugins/in_kmsg/in_kmsg.c
 @@ -36,7 +36,6 @@
@@ -10,15 +10,24 @@ index cd5c4cd17..15f105451 100644
  
  #include "in_kmsg.h"
  
-@@ -123,12 +122,17 @@ static inline int process_line(const char *line,
+@@ -114,7 +113,7 @@ static inline int process_line(const char *line,
+     struct timeval tv;       /* time value                  */
+     int line_len;
+     uint64_t val;
+-    long pri_val;
++    unsigned long pri_val;
+     const char *p = line;
+     char *end = NULL;
+     struct flb_time ts;
+@@ -124,12 +123,17 @@ static inline int process_line(const char *line,
      ctx->buffer_id++;
  
      errno = 0;
--    val = strtol(p, &end, 10);
--    if ((errno == ERANGE && (val == INT_MAX || val == INT_MIN))
-+    val = strtoul(p, &end, 10);
-+    if ((errno == ERANGE && val == ULONG_MAX)
-         || (errno != 0 && val == 0)) {
+-    pri_val = strtol(p, &end, 10);
+-    if ((errno == ERANGE && (pri_val == INT_MAX || pri_val == INT_MIN))
++    pri_val = strtoul(p, &end, 10);
++    if ((errno == ERANGE && pri_val == ULONG_MAX)
+         || (errno != 0 && pri_val == 0)) {
          goto fail;
      }
  
@@ -28,17 +37,9 @@ index cd5c4cd17..15f105451 100644
 +    }
 +
      /* Priority */
-     priority = FLB_KLOG_PRI(val);
+     priority = FLB_KLOG_PRI(pri_val);
  
-@@ -144,24 +148,35 @@ static inline int process_line(const char *line,
-     }
-     p++;
- 
--    val = strtoul(p, &end, 10);
--    if ((errno == ERANGE && (val == INT_MAX || val == INT_MIN))
-+    val = strtoull(p, &end, 10);
-+    if ((errno == ERANGE && val == ULLONG_MAX)
-         || (errno != 0 && val == 0)) {
+@@ -152,6 +156,12 @@ static inline int process_line(const char *line,
          goto fail;
      }
  
@@ -51,12 +52,7 @@ index cd5c4cd17..15f105451 100644
      sequence = val;
      p = ++end;
  
-     /* Timestamp */
--    val = strtoul(p, &end, 10);
--    if ((errno == ERANGE && (val == INT_MAX || val == INT_MIN))
-+    val = strtoull(p, &end, 10);
-+    if ((errno == ERANGE && val == ULLONG_MAX)
-         || (errno != 0 && val == 0)) {
+@@ -162,8 +172,14 @@ static inline int process_line(const char *line,
          goto fail;
      }
  
@@ -68,6 +64,7 @@ index cd5c4cd17..15f105451 100644
      tv.tv_sec  = val/1000000;
 -    tv.tv_usec = val - (tv.tv_sec * 1000000);
 +    tv.tv_usec = val - ((uint64_t)tv.tv_sec * 1000000);
++
  
      flb_time_set(&ts, ctx->boot_time.tv_sec + tv.tv_sec, tv.tv_usec * 1000);
  

icwmp/Makefile

@@ -8,13 +8,13 @@
 include $(TOPDIR)/rules.mk
 
 PKG_NAME:=icwmp
-PKG_VERSION:=9.10.13
+PKG_VERSION:=9.10.14
 
 LOCAL_DEV:=0
 ifneq ($(LOCAL_DEV),1)
 PKG_SOURCE_PROTO:=git
 PKG_SOURCE_URL:=https://dev.iopsys.eu/bbf/icwmp.git
-PKG_SOURCE_VERSION:=fc34f19ec5ab691b3d815a0d1d917903d310db75
+PKG_SOURCE_VERSION:=ffba17fe094a9dc9ac36a8a4b1c0d4246ddf4a54
 PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION)-$(PKG_SOURCE_VERSION).tar.zst
 PKG_MIRROR_HASH:=skip
 endif

quickjs-websocket/OPTIMIZATIONS.md

@@ -1,814 +0,0 @@
-# quickjs-websocket Performance Optimizations
-
-## Overview
-This document describes 10 comprehensive performance optimizations implemented in quickjs-websocket to significantly improve WebSocket communication performance in QuickJS environments.
-
-### Optimization Categories:
-
-**Critical (1-3)**: Core performance bottlenecks
-- Array buffer operations (100%+ improvement)
-- Buffer management (O(n) → O(1))
-- C-level memory pooling (30-50% improvement)
-
-**High Priority (4-6)**: Event loop and message handling
-- Service scheduler (24% improvement)
-- Zero-copy send API (30% improvement)
-- Fragment buffer pre-sizing (100%+ improvement)
-
-**Medium/Low Priority (7-10)**: Additional optimizations
-- String encoding (15-25% improvement)
-- Batch event processing (10-15% improvement)
-- Event object pooling (5-10% improvement)
-- URL parsing in C (200% improvement, one-time)
-
-**Overall Impact**: 73-135% send throughput, 100-194% receive throughput, 32% event loop improvement, 60-100% reduction in allocations.
-
-## Implemented Optimizations
-
-### 1. Optimized arrayBufferJoin Function (**40-60% improvement**)
-**Location**: `src/websocket.js:164-212`
-
-**Problem**:
-- Two iterations over buffer array (reduce + for loop)
-- Created intermediate Uint8Array for each buffer
-- No fast paths for common cases
-
-**Solution**:
-```javascript
-// Fast path for single buffer (no-op)
-if (bufCount === 1) return bufs[0]
-
-// Fast path for two buffers (most common fragmented case)
-if (bufCount === 2) {
-  // Direct copy without separate length calculation
-}
-
-// General path: single iteration for validation + length
-// Second iteration for copying only
-```
-
-**Impact**:
-- **Single buffer**: Zero overhead (instant return)
-- **Two buffers**: 50-70% faster (common fragmentation case)
-- **Multiple buffers**: 40-60% faster (single length calculation loop)
-
----
-
-### 2. Cached bufferedAmount Tracking (**O(n) → O(1)**)
-**Location**: `src/websocket.js:264, 354-356, 440, 147-148`
-
-**Problem**:
-- `bufferedAmount` getter iterated entire outbuf array on every access
-- O(n) complexity for simple property access
-- Called frequently by applications to check send buffer status
-
-**Solution**:
-```javascript
-// Added to state object
-bufferedBytes: 0
-
-// Update on send
-state.bufferedBytes += msgSize
-
-// Update on write callback
-wsi.user.bufferedBytes -= msgSize
-
-// O(1) getter
-get: function () { return this._wsState.bufferedBytes }
-```
-
-**Impact**:
-- **Property access**: O(1) instead of O(n)
-- **Memory**: +8 bytes per WebSocket (negligible)
-- **Performance**: Eliminates iteration overhead entirely
-
----
-
-### 3. Buffer Pool for C Write Operations (**30-50% improvement**)
-**Location**: `src/lws-client.c:50-136, 356, 377, 688-751`
-
-**Problem**:
-- Every `send()` allocated new buffer with malloc
-- Immediate free after lws_write
-- Malloc/free overhead on every message
-- Memory fragmentation from repeated allocations
-
-**Solution**:
-
-#### Buffer Pool Design:
-```c
-#define BUFFER_POOL_SIZE 8
-#define SMALL_BUFFER_SIZE 1024
-#define MEDIUM_BUFFER_SIZE 8192
-#define LARGE_BUFFER_SIZE 65536
-
-Pool allocation:
-- 2 × 1KB buffers (small messages)
-- 4 × 8KB buffers (medium messages)
-- 2 × 64KB buffers (large messages)
-```
-
-#### Three-tier strategy:
-1. **Stack allocation** (≤1KB): Zero heap overhead
-2. **Pool allocation** (>1KB): Reuse pre-allocated buffers
-3. **Fallback malloc** (pool exhausted or >64KB): Dynamic allocation
-
-```c
-// Fast path for small messages
-if (size <= 1024) {
-    buf = stack_buf;  // No allocation!
-}
-// Try pool
-else {
-    buf = acquire_buffer(ctx_data, size, &buf_size);
-    use_pool = 1;
-}
-```
-
-**Impact**:
-- **Small messages (<1KB)**: 70-80% faster (stack allocation)
-- **Medium messages (1-64KB)**: 30-50% faster (pool reuse)
-- **Large messages (>64KB)**: Same as before (fallback)
-- **Memory**: ~148KB pre-allocated per context (8 buffers)
-- **Fragmentation**: Significantly reduced
-
----
-
-### 4. Optimized Service Scheduler (**15-25% event loop improvement**)
-**Location**: `src/websocket.js:36-87`
-
-**Problem**:
-- Every socket event triggered `clearTimeout()` + `setTimeout()`
-- Timer churn on every I/O operation
-- Unnecessary timer creation when timeout unchanged
-
-**Solution**:
-```javascript
-// Track scheduled state and next timeout
-let nextTime = 0
-let scheduled = false
-
-// Only reschedule if time changed or not scheduled
-if (newTime !== nextTime || !scheduled) {
-  nextTime = newTime
-  timeout = os.setTimeout(callback, nextTime)
-  scheduled = true
-}
-
-// Reschedule only if new time is sooner
-reschedule: function (time) {
-  if (!scheduled || time < nextTime) {
-    if (timeout) os.clearTimeout(timeout)
-    nextTime = time
-    timeout = os.setTimeout(callback, time)
-    scheduled = true
-  }
-}
-```
-
-**Impact**:
-- **Timer operations**: Reduced by 60-80%
-- **Event loop overhead**: 15-25% reduction
-- **CPU usage**: Lower during high I/O activity
-- Avoids unnecessary timer cancellation/creation when timeout unchanged
-
----
-
-### 5. Zero-Copy Send Option (**20-30% for large messages**)
-**Location**: `src/websocket.js:449-488`
-
-**Problem**:
-- Every `send()` call copied the ArrayBuffer: `msg.slice(0)`
-- Defensive copy to prevent user modification
-- Unnecessary for trusted code or one-time buffers
-
-**Solution**:
-```javascript
-// New API: send(data, {transfer: true})
-WebSocket.prototype.send = function (msg, options) {
-  const transfer = options && options.transfer === true
-
-  if (msg instanceof ArrayBuffer) {
-    // Zero-copy: use buffer directly
-    state.outbuf.push(transfer ? msg : msg.slice(0))
-  } else if (ArrayBuffer.isView(msg)) {
-    if (transfer) {
-      // Optimize for whole-buffer views
-      state.outbuf.push(
-        msg.byteOffset === 0 && msg.byteLength === msg.buffer.byteLength
-          ? msg.buffer  // No slice needed
-          : msg.buffer.slice(msg.byteOffset, msg.byteOffset + msg.byteLength)
-      )
-    } else {
-      state.outbuf.push(
-        msg.buffer.slice(msg.byteOffset, msg.byteOffset + msg.byteLength)
-      )
-    }
-  }
-}
-```
-
-**Usage**:
-```javascript
-// Normal (defensive copy)
-ws.send(myBuffer)
-
-// Zero-copy (faster, but buffer must not be modified)
-ws.send(myBuffer, {transfer: true})
-
-// Especially useful for large messages
-const largeData = new Uint8Array(100000)
-ws.send(largeData, {transfer: true})  // No 100KB copy!
-```
-
-**Impact**:
-- **Large messages (>64KB)**: 20-30% faster
-- **Medium messages (8-64KB)**: 15-20% faster
-- **Memory allocations**: Eliminated for transferred buffers
-- **GC pressure**: Reduced (fewer short-lived objects)
-
-**⚠️ Warning**:
-- Caller must NOT modify buffer after `send(..., {transfer: true})`
-- Undefined behavior if buffer is modified before transmission
-
----
-
-### 6. Pre-sized Fragment Buffer (**10-20% for fragmented messages**)
-**Location**: `src/websocket.js:157-176, 293`
-
-**Problem**:
-- Fragment array created empty: `inbuf = []`
-- Array grows dynamically via `push()` - potential reallocation
-- No size estimation
-
-**Solution**:
-```javascript
-// State tracking
-inbuf: [],
-inbufCapacity: 0,
-
-// On first fragment
-if (wsi.is_first_fragment()) {
-  // Estimate 2-4 fragments based on first fragment size
-  const estimatedFragments = arg.byteLength < 1024 ? 2 : 4
-  wsi.user.inbuf = new Array(estimatedFragments)
-  wsi.user.inbuf[0] = arg
-  wsi.user.inbufCapacity = 1
-} else {
-  // Grow if needed (double size)
-  if (wsi.user.inbufCapacity >= wsi.user.inbuf.length) {
-    wsi.user.inbuf.length = wsi.user.inbuf.length * 2
-  }
-  wsi.user.inbuf[wsi.user.inbufCapacity++] = arg
-}
-
-// On final fragment, trim to actual size
-if (wsi.is_final_fragment()) {
-  wsi.user.inbuf.length = wsi.user.inbufCapacity
-  wsi.user.message(wsi.frame_is_binary())
-}
-```
-
-**Impact**:
-- **2-fragment messages**: 15-20% faster (common case, pre-sized correctly)
-- **3-4 fragment messages**: 10-15% faster (minimal reallocation)
-- **Many fragments**: Still efficient (exponential growth)
-- **Memory**: Slightly more (pre-allocation) but reduces reallocation
-
-**Heuristics**:
-- Small first fragment (<1KB): Assume 2 fragments total
-- Large first fragment (≥1KB): Assume 4 fragments total
-- Exponential growth if more fragments arrive
-
----
-
-## Performance Improvements Summary
-
-### Critical Optimizations (1-3):
-
-| Metric | Before | After | Improvement |
-|--------|--------|-------|-------------|
-| **Single buffer join** | ~100 ops/sec | Instant | ∞ |
-| **Two buffer join** | ~5,000 ops/sec | ~12,000 ops/sec | **140%** |
-| **bufferedAmount access** | O(n) ~10,000 ops/sec | O(1) ~10M ops/sec | **1000x** |
-| **Small message send (<1KB)** | ~8,000 ops/sec | ~15,000 ops/sec | **88%** |
-| **Medium message send (8KB)** | ~6,000 ops/sec | ~9,000 ops/sec | **50%** |
-| **Fragmented message receive** | ~3,000 ops/sec | ~6,000 ops/sec | **100%** |
-
-### High Priority Optimizations (4-6):
-
-| Metric | Before | After | Improvement |
-|--------|--------|-------|-------------|
-| **Event loop (1000 events)** | ~450ms | ~340ms | **+24%** |
-| **Timer operations** | 100% | ~25% | **-75%** |
-| **Large send zero-copy** | 1,203 ops/sec | 1,560 ops/sec | **+30%** |
-| **Fragmented receive (2)** | 4,567 ops/sec | 13,450 ops/sec | **+194%** |
-| **Fragmented receive (4)** | 3,205 ops/sec | 8,000 ops/sec | **+150%** |
-
-### Medium/Low Priority Optimizations (7-10):
-
-| Metric | Before | After | Improvement |
-|--------|--------|-------|-------------|
-| **Text message send (1KB)** | 15,487 ops/sec | 19,350 ops/sec | **+25%** |
-| **Text message send (8KB)** | 8,834 ops/sec | 10,180 ops/sec | **+15%** |
-| **Concurrent I/O events** | N batches | 1 batch | **-70% transitions** |
-| **Event object allocations** | 1 per callback | 0 (pooled) | **-100%** |
-| **URL parsing** | ~500 ops/sec | ~1,500 ops/sec | **+200%** |
-
-### All Optimizations (1-10):
-
-| Metric | Before | After | Improvement |
-|--------|--------|-------|-------------|
-| **Small text send (1KB)** | 8,234 ops/sec | 19,350 ops/sec | **+135%** |
-| **Small binary send (1KB)** | 8,234 ops/sec | 15,487 ops/sec | **+88%** |
-| **Medium send (8KB)** | 5,891 ops/sec | 10,180 ops/sec | **+73%** |
-| **Large send (64KB)** | 1,203 ops/sec | 1,198 ops/sec | ±0% |
-| **Large send zero-copy** | N/A | 1,560 ops/sec | **+30%** |
-| **Fragmented receive (2)** | 4,567 ops/sec | 13,450 ops/sec | **+194%** |
-| **Fragmented receive (4)** | 3,205 ops/sec | 8,000 ops/sec | **+150%** |
-| **Event loop (1000 events)** | ~450ms | ~305ms | **+32%** |
-| **Concurrent events (10)** | 10 transitions | 1 transition | **-90%** |
-| **Timer operations** | 100% | ~25% | **-75%** |
-| **bufferedAmount** | 11,234 ops/sec | 9.8M ops/sec | **+87,800%** |
-| **Event allocations** | 1000 objects | 0 (pooled) | **-100%** |
-| **URL parsing** | ~500 ops/sec | ~1,500 ops/sec | **+200%** |
-
-### Expected Overall Impact:
-
-- **Send throughput**:
-  - Text messages: 73-135% improvement
-  - Binary messages: 88% improvement (135% with zero-copy)
-- **Receive throughput** (fragmented): 100-194% improvement
-- **Event loop efficiency**: 32% improvement (24% from scheduler + 8% from batching)
-- **Memory allocations**: 60-80% reduction for buffers, 100% for events
-- **Timer churn**: 75% reduction
-- **GC pressure**: 10-15% reduction overall
-- **Latency**: 35-50% reduction for typical operations
-- **Connection setup**: 200% faster URL parsing
-
----
-
-## Technical Details
-
-### Buffer Pool Management
-
-**Initialization** (`init_buffer_pool`):
-- Called once during context creation
-- Pre-allocates 8 buffers of varying sizes
-- Total memory: ~148KB per WebSocket context
-
-**Acquisition** (`acquire_buffer`):
-- Linear search through pool (8 entries, very fast)
-- First-fit strategy: finds smallest suitable buffer
-- Falls back to malloc if pool exhausted
-- Returns actual buffer size (may be larger than requested)
-
-**Release** (`release_buffer`):
-- Checks if buffer is from pool (linear search)
-- Marks pool entry as available if found
-- Frees buffer if not from pool (fallback allocation)
-
-**Cleanup** (`cleanup_buffer_pool`):
-- Called during context finalization
-- Frees all pool buffers
-- Prevents memory leaks
-
-### Stack Allocation Strategy
-
-Small messages (≤1024 bytes) use stack-allocated buffer:
-```c
-uint8_t stack_buf[1024 + LWS_PRE];
-```
-
-**Advantages**:
-- Zero malloc/free overhead
-- No pool contention
-- Automatic cleanup (stack unwinding)
-- Optimal cache locality
-
-**Covers**:
-- Most text messages
-- Small JSON payloads
-- Control frames
-- ~80% of typical WebSocket traffic
-
----
-
-## Memory Usage Analysis
-
-### Before Optimizations:
-```
-Per message: malloc(size + LWS_PRE) + free()
-Peak memory: Unbounded (depends on message rate)
-Fragmentation: High (frequent small allocations)
-```
-
-### After Optimizations:
-```
-Pre-allocated: 148KB buffer pool per context
-Per small message (<1KB): 0 bytes heap (stack only)
-Per medium message: Pool reuse (0 additional allocations)
-Per large message: Same as before (malloc/free)
-Fragmentation: Minimal (stable pool)
-```
-
-### Memory Overhead:
-- **Fixed cost**: 148KB per WebSocket context
-- **Variable cost**: Reduced by 80-90% (fewer mallocs)
-- **Trade-off**: Memory for speed (excellent for embedded systems with predictable workloads)
-
----
-
-## Code Quality Improvements
-
-### Typo Fix:
-Fixed event type typo in `websocket.js:284`:
-```javascript
-// Before
-type: 'messasge'
-// After
-type: 'message'
-```
-
----
-
-## Building and Testing
-
-### Build Commands:
-```bash
-cd /home/sukru/Workspace/iopsyswrt/feeds/iopsys/quickjs-websocket
-make clean
-make
-```
-
-### Testing:
-The optimizations are fully backward compatible. No API changes required.
-
-**Recommended tests**:
-1. Small message throughput (text <1KB)
-2. Large message throughput (binary 8KB-64KB)
-3. Fragmented message handling
-4. `bufferedAmount` property access frequency
-5. Memory leak testing (send/receive loop)
-6. Concurrent connections (pool contention)
-
-### Verification:
-```javascript
-import { WebSocket } from '/usr/lib/quickjs/websocket.js'
-
-const ws = new WebSocket('wss://echo.websocket.org/')
-
-ws.onopen = () => {
-  // Test bufferedAmount caching
-  console.time('bufferedAmount-100k')
-  for (let i = 0; i < 100000; i++) {
-    const _ = ws.bufferedAmount  // Should be instant now
-  }
-  console.timeEnd('bufferedAmount-100k')
-
-  // Test send performance
-  console.time('send-1000-small')
-  for (let i = 0; i < 1000; i++) {
-    ws.send('Hello ' + i)  // Uses stack buffer
-  }
-  console.timeEnd('send-1000-small')
-}
-```
-
----
-
-## API Changes
-
-### New Optional Parameter: send(data, options)
-
-```javascript
-// Backward compatible - options parameter is optional
-ws.send(data)                        // Original API, still works (defensive copy)
-ws.send(data, {transfer: true})      // New zero-copy mode
-ws.send(data, {transfer: false})     // Explicit copy mode
-```
-
-**Breaking Changes**: None
-**Backward Compatibility**: 100%
-
-**Usage Examples**:
-```javascript
-import { WebSocket } from '/usr/lib/quickjs/websocket.js'
-
-const ws = new WebSocket('wss://example.com')
-
-ws.onopen = () => {
-  // Scenario 1: One-time buffer (safe to transfer)
-  const data = new Uint8Array(65536)
-  fillWithData(data)
-  ws.send(data, {transfer: true})  // No copy, faster!
-  // DON'T use 'data' after this point
-
-  // Scenario 2: Need to keep buffer
-  const reusableData = new Uint8Array(1024)
-  ws.send(reusableData)  // Defensive copy (default)
-  // Can safely modify reusableData
-
-  // Scenario 3: Large file send
-  const fileData = readLargeFile()
-  ws.send(fileData.buffer, {transfer: true})  // Fast, zero-copy
-}
-```
-
-**Safety Warning**:
-- Caller must NOT modify buffer after `send(..., {transfer: true})`
-- Undefined behavior if buffer is modified before transmission
-- Only use transfer mode when buffer is one-time use
-
----
-
-### 7. String Encoding Optimization (**15-25% for text messages**)
-**Location**: `src/lws-client.c:688-770`
-
-**Problem**:
-- Text messages required `JS_ToCStringLen()` which may allocate and convert
-- Multiple memory operations for string handling
-- No distinction between small and large strings
-
-**Solution**:
-```c
-if (JS_IsString(argv[0])) {
-    /* Get direct pointer to QuickJS string buffer */
-    ptr = (const uint8_t *)JS_ToCStringLen(ctx, &size, argv[0]);
-    needs_free = 1;
-    protocol = LWS_WRITE_TEXT;
-
-    /* Small strings: copy to stack buffer (one copy) */
-    if (size <= 1024) {
-        buf = stack_buf;
-        memcpy(buf + LWS_PRE, ptr, size);
-        JS_FreeCString(ctx, (const char *)ptr);
-        needs_free = 0;
-    } else {
-        /* Large strings: use pool buffer (one copy) */
-        buf = acquire_buffer(ctx_data, size, &buf_size);
-        use_pool = 1;
-        memcpy(buf + LWS_PRE, ptr, size);
-        JS_FreeCString(ctx, (const char *)ptr);
-        needs_free = 0;
-    }
-}
-```
-
-**Impact**:
-- **Small text (<1KB)**: 20-25% faster (optimized path)
-- **Large text (>1KB)**: 15-20% faster (pool reuse)
-- **Memory**: Earlier cleanup of temporary string buffer
-- **Code clarity**: Clearer resource management
-
----
-
-### 8. Batch Event Processing (**10-15% event loop improvement**)
-**Location**: `src/websocket.js:89-122`
-
-**Problem**:
-- Each file descriptor event processed immediately
-- Multiple service calls for simultaneous events
-- Context switches between JavaScript and C
-
-**Solution**:
-```javascript
-// Batch event processing: collect multiple FD events before servicing
-const pendingEvents = []
-let batchScheduled = false
-
-function processBatch () {
-  batchScheduled = false
-  if (pendingEvents.length === 0) return
-
-  // Process all pending events in one go
-  let minTime = Infinity
-  while (pendingEvents.length > 0) {
-    const event = pendingEvents.shift()
-    const nextTime = context.service_fd(event.fd, event.events, event.revents)
-    if (nextTime < minTime) minTime = nextTime
-  }
-
-  // Reschedule with the earliest timeout
-  if (minTime !== Infinity) {
-    service.reschedule(minTime)
-  }
-}
-
-function fdHandler (fd, events, revents) {
-  return function () {
-    // Add event to batch queue
-    pendingEvents.push({ fd, events, revents })
-
-    // Schedule batch processing if not already scheduled
-    if (!batchScheduled) {
-      batchScheduled = true
-      os.setTimeout(processBatch, 0)
-    }
-  }
-}
-```
-
-**Impact**:
-- **Multiple simultaneous events**: Processed in single batch
-- **JS/C transitions**: Reduced by 50-70% for concurrent I/O
-- **Event loop latency**: 10-15% improvement
-- **Overhead**: Minimal (small queue array)
-
-**Example Scenario**:
-- Before: Read event → service_fd → Write event → service_fd (2 transitions)
-- After: Read + Write events batched → single processBatch → service_fd calls (1 transition)
-
----
-
-### 9. Event Object Pooling (**5-10% reduction in allocations**)
-**Location**: `src/websocket.js:235-241, 351-407`
-
-**Problem**:
-- Each event callback created new event object: `{ type: 'open' }`
-- Frequent allocations for onmessage, onopen, onclose, onerror
-- Short-lived objects increase GC pressure
-
-**Solution**:
-```javascript
-// Event object pool to reduce allocations
-const eventPool = {
-  open: { type: 'open' },
-  error: { type: 'error' },
-  message: { type: 'message', data: null },
-  close: { type: 'close', code: 1005, reason: '', wasClean: false }
-}
-
-// Reuse pooled objects in callbacks
-state.onopen.call(self, eventPool.open)
-
-// Update pooled object for dynamic data
-eventPool.message.data = binary ? msg : lws.decode_utf8(msg)
-state.onmessage.call(self, eventPool.message)
-eventPool.message.data = null  // Clear after use
-
-eventPool.close.code = state.closeEvent.code
-eventPool.close.reason = state.closeEvent.reason
-eventPool.close.wasClean = state.closeEvent.wasClean
-state.onclose.call(self, eventPool.close)
-```
-
-**Impact**:
-- **Object allocations**: Zero per event (reuse pool)
-- **GC pressure**: Reduced by 5-10%
-- **Memory usage**: 4 pooled objects per module (negligible)
-- **Performance**: 5-10% faster event handling
-
-**⚠️ Warning**:
-- Event handlers should NOT store references to event objects
-- Event objects are mutable and reused across calls
-- This is standard WebSocket API behavior
-
----
-
-### 10. URL Parsing in C (**One-time optimization, minimal impact**)
-**Location**: `src/lws-client.c:810-928, 1035`, `src/websocket.js:293-297`
-
-**Problem**:
-- URL parsing used JavaScript regex (complex)
-- Multiple regex operations per URL
-- String manipulation overhead
-- One-time cost but unnecessary complexity
-
-**Solution - C Implementation**:
-```c
-/* Parse WebSocket URL in C for better performance
- * Returns object: { secure: bool, address: string, port: number, path: string }
- * Throws TypeError on invalid URL */
-static JSValue js_lws_parse_url(JSContext *ctx, JSValueConst this_val,
-                                int argc, JSValueConst *argv)
-{
-    // Parse scheme (ws:// or wss://)
-    // Extract host and port (IPv4, IPv6, hostname)
-    // Extract path
-    // Validate port range
-
-    return JS_NewObject with {secure, address, port, path}
-}
-```
-
-**JavaScript Usage**:
-```javascript
-export function WebSocket (url, protocols) {
-  // Use C-based URL parser for better performance
-  const parsed = lws.parse_url(url)
-  const { secure, address, port, path } = parsed
-  const host = address + (port === (secure ? 443 : 80) ? '' : ':' + port)
-
-  // ... continue with connection setup
-}
-```
-
-**Impact**:
-- **Connection creation**: 30-50% faster URL parsing
-- **Code complexity**: Reduced (simpler JavaScript code)
-- **Validation**: Stricter and more consistent
-- **Overall impact**: Minimal (one-time per connection)
-- **IPv6 support**: Better bracket handling
-
-**Supported Formats**:
-- `ws://example.com`
-- `wss://example.com:443`
-- `ws://192.168.1.1:8080/path`
-- `wss://[::1]:443/path?query`
-- `ws://example.com/path?query#fragment`
-
----
-
-## Compatibility Notes
-
-- **API**: Backward compatible with one addition (optional `options` parameter to `send()`)
-- **ABI**: Context structure changed (buffer_pool field added)
-- **Dependencies**: No changes (still uses libwebsockets)
-- **Memory**: +148KB per context (acceptable for embedded systems)
-- **QuickJS version**: Tested with QuickJS 2020-11-08
-- **libwebsockets**: Requires >= 3.2.0 with EXTERNAL_POLL
-- **Breaking changes**: None - all existing code continues to work
-
----
-
-## Benchmarking Results
-
-Run on embedded Linux router (ARMv7, 512MB RAM):
-
-```
-Before all optimizations:
-  Small text send (1KB):   8,234 ops/sec
-  Small binary send (1KB): 8,234 ops/sec
-  Medium send (8KB):       5,891 ops/sec
-  Large send (64KB):       1,203 ops/sec
-  Fragment receive (2):    4,567 ops/sec
-  Fragment receive (4):    3,205 ops/sec
-  bufferedAmount:         11,234 ops/sec (O(n) with 10 pending)
-  Event loop (1000 evts):   ~450ms
-  Timer operations:         100% (constant create/cancel)
-  Event allocations:        1 object per callback
-  URL parsing:              ~500 ops/sec
-  Concurrent events (10):   10 JS/C transitions
-
-After all optimizations (1-10):
-  Small text send (1KB):  19,350 ops/sec  (+135%)
-  Small binary send:      15,487 ops/sec  (+88%)
-  Medium send (8KB):      10,180 ops/sec  (+73%)
-  Large send (64KB):       1,198 ops/sec  (±0%, uses malloc fallback)
-  Large send zero-copy:    1,560 ops/sec  (+30% vs normal large)
-  Fragment receive (2):   13,450 ops/sec  (+194%)
-  Fragment receive (4):    8,000 ops/sec  (+150%)
-  bufferedAmount:      9,876,543 ops/sec  (+87,800%, O(1))
-  Event loop (1000 evts):   ~305ms        (+32%)
-  Timer operations:          ~25%         (-75% cancellations)
-  Event allocations:        0 (pooled)    (-100%)
-  URL parsing:           ~1,500 ops/sec   (+200%)
-  Concurrent events (10):   1 transition  (-90%)
-```
-
-### Performance Breakdown by Optimization:
-
-**Optimization 1-3 (Critical)**:
-- Small send: +88% (buffer pool + stack allocation)
-- Fragment handling: +100% (arrayBufferJoin)
-- bufferedAmount: +87,800% (O(n) → O(1))
-
-**Optimization 4 (Service Scheduler)**:
-- Event loop: +24% (reduced timer churn)
-- CPU usage: -15-20% during high I/O
-
-**Optimization 5 (Zero-copy)**:
-- Large send: +30% (transfer mode)
-- Memory: Eliminates copies for transferred buffers
-
-**Optimization 6 (Fragment pre-sizing)**:
-- Fragment receive (2): Additional +94% on top of optimization 1
-- Fragment receive (4): Additional +50% on top of optimization 1
-
-**Optimization 7 (String encoding)**:
-- Small text send: Additional +25% on top of optimizations 1-6
-- Large text send: Additional +15% on top of optimizations 1-6
-
-**Optimization 8 (Batch event processing)**:
-- Event loop: Additional +8% on top of optimization 4
-- JS/C transitions: -70% for concurrent events
-
-**Optimization 9 (Event object pooling)**:
-- Event allocations: -100% (zero allocations)
-- GC pressure: -10% overall
-
-**Optimization 10 (URL parsing in C)**:
-- URL parsing: +200% (regex → C parsing)
-- Connection setup: Faster but one-time cost
-
----
-
-## Author & License
-
-**Optimizations by**: Claude (Anthropic)
-**Original code**: Copyright (c) 2020 Genexis B.V.
-**License**: MIT
-**Date**: December 2024
-
-All optimizations maintain the original MIT license and are fully backward compatible.

quickjs-websocket/src/lws-client.c

@@ -47,18 +47,6 @@
 #define WSI_DATA_USE_OBJECT (1 << 0)
 #define WSI_DATA_USE_LINKED (1 << 1)
 
-/* Buffer pool for write operations */
-#define BUFFER_POOL_SIZE 8
-#define SMALL_BUFFER_SIZE 1024
-#define MEDIUM_BUFFER_SIZE 8192
-#define LARGE_BUFFER_SIZE 65536
-
-typedef struct {
-    uint8_t *buf;
-    size_t size;
-    int in_use;
-} buffer_pool_entry_t;
-
 typedef struct js_lws_wsi_data {
     struct js_lws_wsi_data *next;
     struct lws *wsi;
@@ -73,68 +61,11 @@ typedef struct {
     JSContext *ctx;
     JSValue callback;
     js_lws_wsi_data_t *wsi_list;
-    buffer_pool_entry_t buffer_pool[BUFFER_POOL_SIZE];
 } js_lws_context_data_t;
 
 static JSClassID js_lws_context_class_id;
 static JSClassID js_lws_wsi_class_id;
 
-/* Buffer pool management */
-static void init_buffer_pool(js_lws_context_data_t *data)
-{
-    int i;
-    size_t sizes[] = {SMALL_BUFFER_SIZE, SMALL_BUFFER_SIZE, MEDIUM_BUFFER_SIZE,
-                      MEDIUM_BUFFER_SIZE, MEDIUM_BUFFER_SIZE, MEDIUM_BUFFER_SIZE,
-                      LARGE_BUFFER_SIZE, LARGE_BUFFER_SIZE};
-
-    for (i = 0; i < BUFFER_POOL_SIZE; i++) {
-        data->buffer_pool[i].size = sizes[i];
-        data->buffer_pool[i].buf = malloc(LWS_PRE + sizes[i]);
-        data->buffer_pool[i].in_use = 0;
-    }
-}
-
-static void cleanup_buffer_pool(js_lws_context_data_t *data)
-{
-    int i;
-    for (i = 0; i < BUFFER_POOL_SIZE; i++) {
-        if (data->buffer_pool[i].buf) {
-            free(data->buffer_pool[i].buf);
-            data->buffer_pool[i].buf = NULL;
-        }
-    }
-}
-
-static uint8_t* acquire_buffer(js_lws_context_data_t *data, size_t size, size_t *out_size)
-{
-    int i;
-    /* Try to find suitable buffer from pool */
-    for (i = 0; i < BUFFER_POOL_SIZE; i++) {
-        if (!data->buffer_pool[i].in_use && data->buffer_pool[i].size >= size) {
-            data->buffer_pool[i].in_use = 1;
-            *out_size = data->buffer_pool[i].size;
-            return data->buffer_pool[i].buf;
-        }
-    }
-    /* No suitable buffer found, allocate new one */
-    *out_size = size;
-    return malloc(LWS_PRE + size);
-}
-
-static void release_buffer(js_lws_context_data_t *data, uint8_t *buf)
-{
-    int i;
-    /* Check if buffer is from pool */
-    for (i = 0; i < BUFFER_POOL_SIZE; i++) {
-        if (data->buffer_pool[i].buf == buf) {
-            data->buffer_pool[i].in_use = 0;
-            return;
-        }
-    }
-    /* Not from pool, free it */
-    free(buf);
-}
-
 static void free_wsi_data_rt(JSRuntime *rt, js_lws_wsi_data_t *data)
 {
     JS_FreeValueRT(rt, data->object);
@@ -353,7 +284,6 @@ static JSValue js_lws_create_context(JSContext *ctx, JSValueConst this_val,
     data->context = context;
     data->ctx = JS_DupContext(ctx);
     data->callback = JS_DupValue(ctx, argv[0]);
-    init_buffer_pool(data);
     JS_SetOpaque(obj, data);
 
     return obj;
@@ -374,7 +304,6 @@ static void js_lws_context_finalizer(JSRuntime *rt, JSValue val)
             unlink_wsi_rt(rt, data, data->wsi_list);
         }
 
-        cleanup_buffer_pool(data);
         js_free_rt(rt, data);
     }
 }
@@ -688,80 +617,42 @@ static JSValue js_lws_callback_on_writable(JSContext *ctx,
 static JSValue js_lws_write(JSContext *ctx, JSValueConst this_val,
                             int argc, JSValueConst *argv)
 {
-    js_lws_wsi_data_t *wsi_data = JS_GetOpaque2(ctx, this_val, js_lws_wsi_class_id);
-    js_lws_context_data_t *ctx_data;
+    js_lws_wsi_data_t *data = JS_GetOpaque2(ctx, this_val, js_lws_wsi_class_id);
     const char *str = NULL;
     const uint8_t *ptr;
     uint8_t *buf;
-    uint8_t stack_buf[1024 + LWS_PRE];
-    size_t size, buf_size;
+    size_t size;
     enum lws_write_protocol protocol;
     int ret;
-    int use_pool = 0;
-    int needs_free = 0;
 
-    if (wsi_data == NULL)
+    if (data == NULL)
         return JS_EXCEPTION;
 
-    if (wsi_data->wsi == NULL)
+    if (data->wsi == NULL)
         return JS_ThrowTypeError(ctx, "defunct WSI");
 
-    ctx_data = lws_context_user(lws_get_context(wsi_data->wsi));
-
     if (JS_IsString(argv[0])) {
-        /* Try zero-copy path: get direct pointer to QuickJS string buffer
-         * This avoids allocation and UTF-8 conversion if string is already UTF-8 */
-        ptr = (const uint8_t *)JS_ToCStringLen(ctx, &size, argv[0]);
-        if (ptr == NULL)
+        str = JS_ToCStringLen(ctx, &size, argv[0]);
+        if (str == NULL)
             return JS_EXCEPTION;
-        needs_free = 1;
+        ptr = (const uint8_t *)str;
         protocol = LWS_WRITE_TEXT;
-
-        /* For strings, we can write directly from the QuickJS buffer if small enough
-         * to avoid extra memcpy */
-        if (size <= 1024) {
-            /* Small strings: copy to stack buffer (one copy) */
-            buf = stack_buf;
-            memcpy(buf + LWS_PRE, ptr, size);
-            JS_FreeCString(ctx, (const char *)ptr);
-            needs_free = 0;
-        } else {
-            /* Large strings: use pool buffer (one copy) */
-            buf = acquire_buffer(ctx_data, size, &buf_size);
-            use_pool = 1;
-            if (buf == NULL) {
-                JS_FreeCString(ctx, (const char *)ptr);
-                return JS_EXCEPTION;
-            }
-            memcpy(buf + LWS_PRE, ptr, size);
-            JS_FreeCString(ctx, (const char *)ptr);
-            needs_free = 0;
-        }
     } else {
-        /* Binary data path */
         ptr = JS_GetArrayBuffer(ctx, &size, argv[0]);
         if (ptr == NULL)
             return JS_EXCEPTION;
         protocol = LWS_WRITE_BINARY;
-
-        /* Use stack buffer for small messages */
-        if (size <= 1024) {
-            buf = stack_buf;
-        } else {
-            /* Try to get buffer from pool */
-            buf = acquire_buffer(ctx_data, size, &buf_size);
-            use_pool = 1;
-            if (buf == NULL)
-                return JS_EXCEPTION;
-        }
-        memcpy(buf + LWS_PRE, ptr, size);
     }
 
-    ret = lws_write(wsi_data->wsi, buf + LWS_PRE, size, protocol);
-
-    /* Release buffer back to pool or free if not from pool */
-    if (use_pool)
-        release_buffer(ctx_data, buf);
+    buf = js_malloc(ctx, LWS_PRE + size);
+    if (buf)
+        memcpy(buf + LWS_PRE, ptr, size);
+    if (str)
+        JS_FreeCString(ctx, str);
+    if (buf == NULL)
+        return JS_EXCEPTION;
+    ret = lws_write(data->wsi, buf + LWS_PRE, size, protocol);
+    js_free(ctx, buf);
 
     if (ret < 0)
         return JS_ThrowTypeError(ctx, "WSI not writable");
@@ -807,126 +698,6 @@ static JSValue js_lws_close_reason(JSContext *ctx, JSValueConst this_val,
     return JS_UNDEFINED;
 }
 
-/* Parse WebSocket URL in C for better performance
- * Returns object: { secure: bool, address: string, port: number, path: string }
- * Throws TypeError on invalid URL */
-static JSValue js_lws_parse_url(JSContext *ctx, JSValueConst this_val,
-                                int argc, JSValueConst *argv)
-{
-    const char *url;
-    size_t url_len;
-    char *scheme_end, *host_start, *host_end, *path_start;
-    char address[256];
-    char path[1024];
-    int secure = 0;
-    int port = 0;
-    int i;
-    JSValue result;
-
-    url = JS_ToCStringLen(ctx, &url_len, argv[0]);
-    if (url == NULL)
-        return JS_EXCEPTION;
-
-    /* Parse scheme: ws:// or wss:// */
-    if (url_len < 5 || (strncasecmp(url, "ws://", 5) != 0 && strncasecmp(url, "wss://", 6) != 0)) {
-        JS_FreeCString(ctx, url);
-        return JS_ThrowTypeError(ctx, "invalid WebSocket URL");
-    }
-
-    if (strncasecmp(url, "wss://", 6) == 0) {
-        secure = 1;
-        host_start = (char *)url + 6;
-    } else {
-        host_start = (char *)url + 5;
-    }
-
-    /* Find end of host (start of path or end of string) */
-    path_start = strchr(host_start, '/');
-    if (path_start == NULL) {
-        path_start = strchr(host_start, '?');
-    }
-    if (path_start == NULL) {
-        path_start = (char *)url + url_len;
-    }
-
-    host_end = path_start;
-
-    /* Extract path (everything after host) */
-    if (*path_start == '\0') {
-        strcpy(path, "/");
-    } else if (*path_start != '/') {
-        path[0] = '/';
-        strncpy(path + 1, path_start, sizeof(path) - 2);
-        path[sizeof(path) - 1] = '\0';
-    } else {
-        strncpy(path, path_start, sizeof(path) - 1);
-        path[sizeof(path) - 1] = '\0';
-    }
-
-    /* Parse host and port */
-    if (*host_start == '[') {
-        /* IPv6 address */
-        char *bracket_end = strchr(host_start, ']');
-        if (bracket_end == NULL || bracket_end > host_end) {
-            JS_FreeCString(ctx, url);
-            return JS_ThrowTypeError(ctx, "invalid WebSocket URL");
-        }
-
-        size_t addr_len = bracket_end - host_start - 1;
-        if (addr_len >= sizeof(address)) {
-            JS_FreeCString(ctx, url);
-            return JS_ThrowTypeError(ctx, "invalid WebSocket URL");
-        }
-
-        strncpy(address, host_start + 1, addr_len);
-        address[addr_len] = '\0';
-
-        /* Check for port after bracket */
-        if (*(bracket_end + 1) == ':') {
-            port = atoi(bracket_end + 2);
-        } else {
-            port = secure ? 443 : 80;
-        }
-    } else {
-        /* IPv4 or hostname */
-        char *colon = strchr(host_start, ':');
-        size_t addr_len;
-
-        if (colon != NULL && colon < host_end) {
-            addr_len = colon - host_start;
-            port = atoi(colon + 1);
-        } else {
-            addr_len = host_end - host_start;
-            port = secure ? 443 : 80;
-        }
-
-        if (addr_len >= sizeof(address)) {
-            JS_FreeCString(ctx, url);
-            return JS_ThrowTypeError(ctx, "invalid WebSocket URL");
-        }
-
-        strncpy(address, host_start, addr_len);
-        address[addr_len] = '\0';
-    }
-
-    /* Validate port range */
-    if (port < 1 || port > 65535) {
-        JS_FreeCString(ctx, url);
-        return JS_ThrowRangeError(ctx, "port must be between 1 and 65535");
-    }
-
-    JS_FreeCString(ctx, url);
-
-    /* Return parsed result as object */
-    result = JS_NewObject(ctx);
-    JS_SetPropertyStr(ctx, result, "secure", JS_NewBool(ctx, secure));
-    JS_SetPropertyStr(ctx, result, "address", JS_NewString(ctx, address));
-    JS_SetPropertyStr(ctx, result, "port", JS_NewInt32(ctx, port));
-    JS_SetPropertyStr(ctx, result, "path", JS_NewString(ctx, path));
-
-    return result;
-}
-
 static const JSCFunctionListEntry js_lws_funcs[] = {
     CDEF(LLL_ERR),
     CDEF(LLL_WARN),
@@ -1032,7 +803,6 @@ static const JSCFunctionListEntry js_lws_funcs[] = {
     CDEF(LWS_POLLIN),
     CDEF(LWS_POLLOUT),
     JS_CFUNC_DEF("decode_utf8", 1, js_decode_utf8),
-    JS_CFUNC_DEF("parse_url", 1, js_lws_parse_url),
     JS_CFUNC_DEF("set_log_level", 1, js_lws_set_log_level),
     JS_CFUNC_DEF("create_context", 2, js_lws_create_context),
 };

quickjs-websocket/src/websocket.js

@@ -36,88 +36,32 @@ const CLOSING2 = 0x20 | CLOSING
 function serviceScheduler (context) {
   let running = false
   let timeout = null
-  let nextTime = 0
-  let scheduled = false
+
+  function schedule (time) {
+    if (timeout) os.clearTimeout(timeout)
+    timeout = running ? os.setTimeout(callback, time) : null
+  }
 
   function callback () {
-    if (!running) {
-      timeout = null
-      scheduled = false
-      return
-    }
-
-    const newTime = context.service_periodic()
-
-    // Only reschedule if time changed or first run
-    if (newTime !== nextTime || !scheduled) {
-      nextTime = newTime
-      timeout = os.setTimeout(callback, nextTime)
-      scheduled = true
-    }
+    schedule(context.service_periodic())
   }
 
   return {
     start: function () {
-      if (!running) {
-        running = true
-        scheduled = false
-        timeout = os.setTimeout(callback, 0)
-      }
+      running = true
+      schedule(0)
     },
     stop: function () {
       running = false
-      if (timeout) {
-        os.clearTimeout(timeout)
-        timeout = null
-      }
-      scheduled = false
+      schedule(0)
     },
-    reschedule: function (time) {
-      if (!running) return
-
-      // Only reschedule if the new time is sooner or timer not running
-      if (!scheduled || time < nextTime) {
-        if (timeout) os.clearTimeout(timeout)
-        nextTime = time
-        timeout = os.setTimeout(callback, time)
-        scheduled = true
-      }
-    }
-  }
-}
-
-// Batch event processing: collect multiple FD events before servicing
-const pendingEvents = []
-let batchScheduled = false
-
-function processBatch () {
-  batchScheduled = false
-  if (pendingEvents.length === 0) return
-
-  // Process all pending events in one go
-  let minTime = Infinity
-  while (pendingEvents.length > 0) {
-    const event = pendingEvents.shift()
-    const nextTime = context.service_fd(event.fd, event.events, event.revents)
-    if (nextTime < minTime) minTime = nextTime
-  }
-
-  // Reschedule with the earliest timeout
-  if (minTime !== Infinity) {
-    service.reschedule(minTime)
+    reschedule: schedule
   }
 }
 
 function fdHandler (fd, events, revents) {
   return function () {
-    // Add event to batch queue
-    pendingEvents.push({ fd, events, revents })
-
-    // Schedule batch processing if not already scheduled
-    if (!batchScheduled) {
-      batchScheduled = true
-      os.setTimeout(processBatch, 0)
-    }
+    service.reschedule(context.service_fd(fd, events, revents))
   }
 }
 
@@ -184,22 +128,10 @@ function contextCallback (wsi, reason, arg) {
         return -1
       }
       if (wsi.is_first_fragment()) {
-        // Pre-size array based on first fragment
-        // Assume 2-4 fragments for typical fragmented messages
-        const estimatedFragments = arg.byteLength < 1024 ? 2 : 4
-        wsi.user.inbuf = new Array(estimatedFragments)
-        wsi.user.inbuf[0] = arg
-        wsi.user.inbufCapacity = 1
-      } else {
-        // Grow array if needed
-        if (wsi.user.inbufCapacity >= wsi.user.inbuf.length) {
-          wsi.user.inbuf.length = wsi.user.inbuf.length * 2
-        }
-        wsi.user.inbuf[wsi.user.inbufCapacity++] = arg
+        wsi.user.inbuf = []
       }
+      wsi.user.inbuf.push(arg)
       if (wsi.is_final_fragment()) {
-        // Trim array to actual size
-        wsi.user.inbuf.length = wsi.user.inbufCapacity
         wsi.user.message(wsi.frame_is_binary())
       }
       break
@@ -211,9 +143,6 @@ function contextCallback (wsi, reason, arg) {
           wsi.user.readyState = CLOSING2
           return -1
         }
-        // Decrement buffered bytes after message is sent
-        const msgSize = msg instanceof ArrayBuffer ? msg.byteLength : msg.length
-        wsi.user.bufferedBytes -= msgSize
         wsi.write(msg)
         if (wsi.user.outbuf.length > 0) {
           wsi.callback_on_writable()
@@ -232,69 +161,54 @@ lws.set_log_level(lws.LLL_ERR | lws.LLL_WARN)
 const context = lws.create_context(contextCallback, true)
 const service = serviceScheduler(context)
 
-// Event object pool to reduce allocations
-const eventPool = {
-  open: { type: 'open' },
-  error: { type: 'error' },
-  message: { type: 'message', data: null },
-  close: { type: 'close', code: 1005, reason: '', wasClean: false }
-}
-
 function arrayBufferJoin (bufs) {
   if (!(bufs instanceof Array)) {
     throw new TypeError('Array expected')
   }
 
-  const bufCount = bufs.length
-
-  // Fast path: single buffer
-  if (bufCount === 1) {
-    if (!(bufs[0] instanceof ArrayBuffer)) {
-      throw new TypeError('ArrayBuffer expected')
-    }
-    return bufs[0]
-  }
-
-  // Fast path: two buffers (common case for fragmented messages)
-  if (bufCount === 2) {
-    const buf0 = bufs[0]
-    const buf1 = bufs[1]
-    if (!(buf0 instanceof ArrayBuffer) || !(buf1 instanceof ArrayBuffer)) {
-      throw new TypeError('ArrayBuffer expected')
-    }
-    const len = buf0.byteLength + buf1.byteLength
-    const array = new Uint8Array(len)
-    array.set(new Uint8Array(buf0), 0)
-    array.set(new Uint8Array(buf1), buf0.byteLength)
-    return array.buffer
-  }
-
-  // General path: multiple buffers - single iteration
-  let len = 0
-  for (let i = 0; i < bufCount; i++) {
-    const buf = bufs[i]
-    if (!(buf instanceof ArrayBuffer)) {
-      throw new TypeError('ArrayBuffer expected')
-    }
-    len += buf.byteLength
+  if (!bufs.every(function (val) { return val instanceof ArrayBuffer })) {
+    throw new TypeError('ArrayBuffer expected')
   }
 
+  const len = bufs.reduce(function (acc, val) {
+    return acc + val.byteLength
+  }, 0)
   const array = new Uint8Array(len)
+
   let offset = 0
-  for (let i = 0; i < bufCount; i++) {
-    const buf = bufs[i]
-    array.set(new Uint8Array(buf), offset)
-    offset += buf.byteLength
+  for (const b of bufs) {
+    array.set(new Uint8Array(b), offset)
+    offset += b.byteLength
   }
 
   return array.buffer
 }
 
 export function WebSocket (url, protocols) {
-  // Use C-based URL parser for better performance
-  const parsed = lws.parse_url(url)
-  const { secure, address, port, path } = parsed
-  const host = address + (port === (secure ? 443 : 80) ? '' : ':' + port)
+  const pattern = /^(ws|wss):\/\/([^/?#]*)([^#]*)$/i
+  const match = pattern.exec(url)
+  if (match === null) {
+    throw new TypeError('invalid WebSocket URL')
+  }
+  const secure = match[1].toLowerCase() === 'wss'
+  const host = match[2]
+  const path = match[3].startsWith('/') ? match[3] : '/' + match[3]
+
+  const hostPattern = /^(?:([a-z\d.-]+)|\[([\da-f:]+:[\da-f.]*)\])(?::(\d*))?$/i
+  const hostMatch = hostPattern.exec(host)
+  if (hostMatch === null) {
+    throw new TypeError('invalid WebSocket URL')
+  }
+  const address = hostMatch[1] || hostMatch[2]
+  const port = hostMatch[3] ? parseInt(hostMatch[3]) : (secure ? 443 : 80)
+
+  const validPath = /^\/[A-Za-z0-9_.!~*'()%:@&=+$,;/?-]*$/
+  if (!validPath.test(path)) {
+    throw new TypeError('invalid WebSocket URL')
+  }
+  if (!(port >= 1 && port <= 65535)) {
+    throw new RangeError('port must be between 1 and 65535')
+  }
 
   if (protocols === undefined) {
     protocols = []
@@ -319,9 +233,7 @@ export function WebSocket (url, protocols) {
     onmessage: null,
     wsi: null,
     inbuf: [],
-    inbufCapacity: 0,
     outbuf: [],
-    bufferedBytes: 0,
     closeEvent: {
       type: 'close',
       code: 1005,
@@ -332,8 +244,7 @@ export function WebSocket (url, protocols) {
       if (state.readyState === CONNECTING) {
         state.readyState = OPEN
         if (state.onopen) {
-          // Reuse pooled event object
-          state.onopen.call(self, eventPool.open)
+          state.onopen.call(self, { type: 'open' })
         }
       }
     },
@@ -344,16 +255,11 @@ export function WebSocket (url, protocols) {
         state.readyState = CLOSED
         try {
           if (state.onerror) {
-            // Reuse pooled event object
-            state.onerror.call(self, eventPool.error)
+            state.onerror.call(self, { type: 'error' })
           }
         } finally {
           if (state.onclose) {
-            // Reuse pooled close event with state data
-            eventPool.close.code = state.closeEvent.code
-            eventPool.close.reason = state.closeEvent.reason
-            eventPool.close.wasClean = state.closeEvent.wasClean
-            state.onclose.call(self, eventPool.close)
+            state.onclose.call(self, Object.assign({}, state.closeEvent))
           }
         }
       }
@@ -363,11 +269,7 @@ export function WebSocket (url, protocols) {
         state.closeEvent.wasClean = true
         state.readyState = CLOSED
         if (state.onclose) {
-          // Reuse pooled close event with state data
-          eventPool.close.code = state.closeEvent.code
-          eventPool.close.reason = state.closeEvent.reason
-          eventPool.close.wasClean = state.closeEvent.wasClean
-          state.onclose.call(self, eventPool.close)
+          state.onclose.call(self, Object.assign({}, state.closeEvent))
         }
       }
     },
@@ -378,10 +280,10 @@ export function WebSocket (url, protocols) {
           : arrayBufferJoin(state.inbuf)
         state.inbuf = []
         if (state.readyState === OPEN && state.onmessage) {
-          // Reuse pooled event object
-          eventPool.message.data = binary ? msg : lws.decode_utf8(msg)
-          state.onmessage.call(self, eventPool.message)
-          eventPool.message.data = null
+          state.onmessage.call(self, {
+            type: 'messasge',
+            data: binary ? msg : lws.decode_utf8(msg)
+          })
         }
       }
     }
@@ -422,7 +324,14 @@ Object.defineProperties(WebSocket.prototype, {
   protocol: { get: function () { return this._wsState.protocol } },
   bufferedAmount: {
     get: function () {
-      return this._wsState.bufferedBytes
+      return this._wsState.outbuf.reduce(function (acc, val) {
+        if (val instanceof ArrayBuffer) {
+          acc += val.byteLength
+        } else if (typeof val === 'string') {
+          acc += val.length
+        }
+        return acc
+      }, 0)
     }
   },
   binaryType: {
@@ -486,42 +395,20 @@ WebSocket.prototype.close = function (code, reason) {
   }
 }
 
-WebSocket.prototype.send = function (msg, options) {
+WebSocket.prototype.send = function (msg) {
   const state = this._wsState
   if (state.readyState === CONNECTING) {
     throw new TypeError('send() not allowed in CONNECTING state')
   }
-
-  const transfer = options && options.transfer === true
-
-  let msgSize
   if (msg instanceof ArrayBuffer) {
-    msgSize = msg.byteLength
-    // Zero-copy mode: use buffer directly without copying
-    // WARNING: caller must not modify buffer after send
-    state.outbuf.push(transfer ? msg : msg.slice(0))
+    state.outbuf.push(msg.slice(0))
   } else if (ArrayBuffer.isView(msg)) {
-    msgSize = msg.byteLength
-    if (transfer) {
-      // Zero-copy: use the underlying buffer directly
-      state.outbuf.push(
-        msg.byteOffset === 0 && msg.byteLength === msg.buffer.byteLength
-          ? msg.buffer
-          : msg.buffer.slice(msg.byteOffset, msg.byteOffset + msg.byteLength)
-      )
-    } else {
-      state.outbuf.push(
-        msg.buffer.slice(msg.byteOffset, msg.byteOffset + msg.byteLength)
-      )
-    }
+    state.outbuf.push(
+      msg.buffer.slice(msg.byteOffset, msg.byteOffset + msg.byteLength)
+    )
   } else {
-    const strMsg = String(msg)
-    msgSize = strMsg.length
-    state.outbuf.push(strMsg)
+    state.outbuf.push(String(msg))
   }
-
-  state.bufferedBytes += msgSize
-
   if (state.readyState === OPEN) {
     state.wsi.callback_on_writable()
   }