Speed up de/serialization of func args and return values in the OPFS VFS proxy.

FossilOrigin-Name: 5bf235bbe035e4ace7a54851e190742528af6b4266328a1b8bbb9fb3dd7f2118

1 files changed, 98 insertions, 29 deletions

diff --git a/ext/wasm/sqlite3-opfs-async-proxy.js b/ext/wasm/sqlite3-opfs-async-proxy.js
index 6caf21597..7c5e8430b 100644
--- a/ext/wasm/sqlite3-opfs-async-proxy.js
+++ b/ext/wasm/sqlite3-opfs-async-proxy.js
@@ -67,6 +67,11 @@ metrics.reset = ()=>{
   for(k in state.opIds){
     r(metrics[k] = Object.create(null));
   }
+  let s = metrics.s11n = Object.create(null);
+  s = s.serialize = Object.create(null);
+  s.count = s.time = 0;
+  s = metrics.s11n.deserialize = Object.create(null);
+  s.count = s.time = 0;
 };
 metrics.dump = ()=>{
   let k, n = 0, t = 0, w = 0;
@@ -83,6 +88,7 @@ metrics.dump = ()=>{
               /*dev console can't expand this object!*/,
               "\nTotal of",n,"op(s) for",t,"ms",
               "approx",w,"ms spent waiting on OPFS APIs.");
+  console.log("Serialization metrics:",JSON.stringify(metrics.s11n,0,2));
 };
 
 warn("This file is very much experimental and under construction.",
@@ -408,55 +414,118 @@ const vfsAsyncImpls = {
 
 const initS11n = ()=>{
   // Achtung: this code is 100% duplicated in the other half of this proxy!
+
+  /**
+     Historical note: this impl was initially about 1% this size by using
+     using JSON.stringify/parse(), but using fit-to-purpose serialization
+     saves considerable runtime.
+  */
+
   if(state.s11n) return state.s11n;
-  const jsonDecoder = new TextDecoder(),
-        jsonEncoder = new TextEncoder('utf-8'),
-        viewSz = new DataView(state.sabIO, state.sabS11nOffset, 4),
-        viewJson = new Uint8Array(state.sabIO, state.sabS11nOffset+4, state.sabS11nSize-4);
+  const textDecoder = new TextDecoder(),
+  textEncoder = new TextEncoder('utf-8'),
+  viewU8 = new Uint8Array(state.sabIO, state.sabS11nOffset, state.sabS11nSize),
+  viewDV = new DataView(state.sabIO, state.sabS11nOffset, state.sabS11nSize);
   state.s11n = Object.create(null);
+
+  const TypeIds = Object.create(null);
+  TypeIds.number  = { id: 1, size: 8, getter: 'getFloat64', setter: 'setFloat64' };
+  TypeIds.bigint  = { id: 2, size: 8, getter: 'getBigInt64', setter: 'setBigInt64' };
+  TypeIds.boolean = { id: 3, size: 4, getter: 'getInt32', setter: 'setInt32' };
+  TypeIds.string =  { id: 4 };
+
+  const getTypeId = (v)=>{
+    return TypeIds[typeof v] || toss("This value type cannot be serialized.",v);
+  };
+  const getTypeIdById = (tid)=>{
+    switch(tid){
+    case TypeIds.number.id: return TypeIds.number;
+    case TypeIds.bigint.id: return TypeIds.bigint;
+    case TypeIds.boolean.id: return TypeIds.boolean;
+    case TypeIds.string.id: return TypeIds.string;
+    default: toss("Invalid type ID:",tid);
+    }
+  };
+
   /**
      Returns an array of the state serialized by the most recent
      serialize() operation (here or in the counterpart thread), or
      null if the serialization buffer is empty.
   */
   state.s11n.deserialize = function(){
-    const sz = viewSz.getInt32(0, state.littleEndian);
-    const json = sz ? jsonDecoder.decode(
-      viewJson.slice(0, sz)
-      /* slice() (copy) needed, instead of subarray() (reference),
-         because TextDecoder throws if asked to decode from an
-         SAB. */
-    ) : null;
-    return JSON.parse(json);
-  }
+    ++metrics.s11n.deserialize.count;
+    const t = performance.now();
+    let rc = null;
+    const argc = viewU8[0];
+    if(argc){
+      rc = [];
+      let offset = 1, i, n, v, typeIds = [];
+      for(i = 0; i < argc; ++i, ++offset){
+        typeIds.push(getTypeIdById(viewU8[offset]));
+      }
+      for(i = 0; i < argc; ++i){
+        const t = typeIds[i];
+        if(t.getter){
+          v = viewDV[t.getter](offset, state.littleEndian);
+          offset += t.size;
+        }else{
+          n = viewDV.getInt32(offset, state.littleEndian);
+          offset += 4;
+          v = textDecoder.decode(viewU8.slice(offset, offset+n));
+          offset += n;
+        }
+        rc.push(v);
+      }
+    }
+    //log("deserialize:",argc, rc);
+    metrics.s11n.deserialize.time += performance.now() - t;
+    return rc;
+  };
+
   /**
      Serializes all arguments to the shared buffer for consumption
-     by the counterpart thread. This impl currently uses JSON for
-     serialization for simplicy of implementation, but if that
-     proves imperformant then a lower-level approach will be
-     created.
-
-     If passed "too much data" (more that the shared buffer size
-     it will either throw or truncate the data (not certain
-     which)). This routine is only intended for serializing OPFS
-     VFS arguments and (in at least one special case) result
-     values, and the buffer is sized to be able to comfortably
-     handle those.
+     by the counterpart thread.
+
+     This routine is only intended for serializing OPFS VFS
+     arguments and (in at least one special case) result values,
+     and the buffer is sized to be able to comfortably handle
+     those.
 
      If passed no arguments then it zeroes out the serialization
      state.
   */
   state.s11n.serialize = function(...args){
+    ++metrics.s11n.serialize.count;
+    const t = performance.now();
     if(args.length){
-      const json = jsonEncoder.encode(JSON.stringify(args));
-      viewSz.setInt32(0, json.byteLength, state.littleEndian);
-      viewJson.set(json);
+      //log("serialize():",args);
+      let i = 0, offset = 1, typeIds = [];
+      viewU8[0] = args.length & 0xff;
+      for(; i < args.length; ++i, ++offset){
+        typeIds.push(getTypeId(args[i]));
+        viewU8[offset] = typeIds[i].id;
+      }
+      for(i = 0; i < args.length; ++i) {
+        const t = typeIds[i];
+        if(t.setter){
+          viewDV[t.setter](offset, args[i], state.littleEndian);
+          offset += t.size;
+        }else{
+          const s = textEncoder.encode(args[i]);
+          viewDV.setInt32(offset, s.byteLength, state.littleEndian);
+          offset += 4;
+          viewU8.set(s, offset);
+          offset += s.byteLength;
+        }
+      }
+      //log("serialize() result:",viewU8.slice(0,offset));
     }else{
-      viewSz.setInt32(0, 0, state.littleEndian);
+      viewU8[0] = 0;
     }
+    metrics.s11n.serialize.time += performance.now() - t;
   };
   return state.s11n;
-};
+}/*initS11n()*/;
 
 const waitLoop = async function f(){
   const opHandlers = Object.create(null);