teyyare 0.2.7 → 0.2.9

package/src/receiver/pipeline.js

@@ -9,7 +9,7 @@ import { existsSync, createReadStream } from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { crc32 } from '../core/crc32.js';
-import { Opcodes, unpackChunkMeta, unpackFileBegin, unpackTransferBegin, unpackFileEnd, unpackPullError } from '../core/protocol.js';
+import { Opcodes, unpackChunkMeta, unpackFileBegin, unpackTransferBegin, unpackFileEnd, unpackTransferEnd, unpackPullError } from '../core/protocol.js';
 import { unpackGeneration } from '../core/generation.js';
 import { FileResumeState } from '../resume/state.js';
 
@@ -38,11 +38,15 @@ export class ReceiverPipeline {
     this.activeFiles = new Map(); // fileId -> { destPath, partPath, statePath, fileHandle, resumeState, ... }
     this.completedFiles = new Set();
     this._pendingChunks = new Map(); // fileId -> Array<{ key, val }>
+    this._pendingFileEnds = new Map(); // fileId -> unpacked FileEnd meta
     this._pendingTransferEnd = false;
     this.transferFinished = false;
     this.transferError = null;
     this._finishResolvers = [];
     this._errorRejecters = [];
+    this.currentTransferId = null;
+    this.expectedFileCount = null;
+    this._completedFileCount = 0;
 
     // Processing queue to ensure strictly ordered, serialized generation processing
     this._batchQueue = [];
@@ -126,7 +130,8 @@ export class ReceiverPipeline {
     const entries = unpackGeneration(metaBuf, payloadBuf);
     const count = entries.length;
 
-    for (let i = 0; i < count; i++) {
+    let i = 0;
+    while (i < count) {
       const { type, key, val } = entries[i];
 
       if (this.metrics) {
@@ -135,34 +140,59 @@ export class ReceiverPipeline {
 
       switch (type) {
         case Opcodes.TRANSFER_BEGIN: {
-          this.transferFinished = false;
-          this.transferError = null;
-          this._pendingTransferEnd = false;
           const tinfo = unpackTransferBegin(key);
+          if (this.currentTransferId !== tinfo.transferId) {
+            if (!this.currentTransferId) {
+              this.currentTransferId = tinfo.transferId;
+            } else {
+              this.currentTransferId = tinfo.transferId;
+              this.transferFinished = false;
+              this.transferError = null;
+              this._pendingTransferEnd = false;
+              this.completedFiles.clear();
+              this._completedFileCount = 0;
+            }
+          }
+          this.expectedFileCount = tinfo.fileCount;
+          this.expectedTotalBytes = tinfo.totalBytes;
+          this._checkTransferCompletion();
+          i++;
           break;
         }
 
         case Opcodes.FILE_BEGIN: {
           await this._handleFileBegin(key);
+          i++;
           break;
         }
 
         case Opcodes.CHUNK: {
-          await this._handleChunk(key, val);
+          const chunkBatch = [];
+          while (i < count && entries[i].type === Opcodes.CHUNK) {
+            chunkBatch.push(entries[i]);
+            if (chunkBatch.length > 1 && this.metrics) {
+              this.metrics.mutations++;
+            }
+            i++;
+          }
+          await this._handleChunks(chunkBatch);
           break;
         }
 
         case Opcodes.FILE_END: {
           await this._handleFileEnd(key);
+          i++;
           break;
         }
 
         case Opcodes.TRANSFER_END: {
-          if (this.activeFiles.size === 0) {
-            this._finishTransfer();
-          } else {
-            this._pendingTransferEnd = true;
+          const tend = unpackTransferEnd(key);
+          if (!this.currentTransferId) {
+            this.currentTransferId = tend.transferId;
           }
+          this._pendingTransferEnd = true;
+          this._checkTransferCompletion();
+          i++;
           break;
         }
 
@@ -177,10 +207,24 @@ export class ReceiverPipeline {
           this._errorRejecters = [];
           return;
         }
+
+        default:
+          i++;
+          break;
       }
     }
   }
 
+  _checkTransferCompletion() {
+    if (!this._pendingTransferEnd) return;
+    if (this.activeFiles.size > 0) return;
+    if (this._pendingFileEnds.size > 0) return;
+    if (this.expectedFileCount !== null && this._completedFileCount < this.expectedFileCount) {
+      return;
+    }
+    this._finishTransfer();
+  }
+
   _finishTransfer() {
     this.transferFinished = true;
     for (const resolve of this._finishResolvers) {
@@ -204,12 +248,22 @@ export class ReceiverPipeline {
       resumeState = new FileResumeState({
         fileId: info.fileId,
         fileSize: Number(info.fileSize),
+        chunkSize: info.chunkSize || 1048576,
         sha256: info.sha256
       });
       await resumeState.save(statePath);
+    } else if (info.chunkSize && resumeState.chunkSize !== info.chunkSize) {
+      resumeState.chunkSize = info.chunkSize;
     }
 
     const fileHandle = await fs.open(partPath, 'a+');
+    const targetSize = Number(info.fileSize);
+    if (targetSize > 0) {
+      const currentStat = await fileHandle.stat();
+      if (currentStat.size < targetSize) {
+        await fileHandle.truncate(targetSize);
+      }
+    }
 
     const file = {
       fileId: info.fileId,
@@ -222,6 +276,9 @@ export class ReceiverPipeline {
       fileSize: Number(info.fileSize),
       sha256: info.sha256,
       chunksWrittenSinceSave: 0,
+      lastStateSaveTime: Date.now(),
+      _stateSaving: false,
+      _pendingStateSave: false,
       pendingEnd: false,
       endMeta: null
     };
@@ -246,9 +303,19 @@ export class ReceiverPipeline {
     const pending = this._pendingChunks.get(info.fileId);
     if (pending && pending.length > 0) {
       this._pendingChunks.delete(info.fileId);
-      for (const item of pending) {
-        const meta = unpackChunkMeta(item.key);
-        await this._writeChunk(file, meta, item.val);
+      await this._writeChunkRun(file, pending);
+    }
+
+    // Check if FILE_END arrived out-of-order before FILE_BEGIN
+    const pendingEnd = this._pendingFileEnds.get(info.fileId);
+    if (pendingEnd) {
+      this._pendingFileEnds.delete(info.fileId);
+      if (pendingEnd.sha256) file.sha256 = pendingEnd.sha256;
+      if (file.fileSize === 0 || file.resumeState.isComplete()) {
+        await this._finalizeFile(file);
+      } else {
+        file.pendingEnd = true;
+        file.endMeta = pendingEnd;
       }
     }
   }
@@ -265,56 +332,164 @@ export class ReceiverPipeline {
         pending = [];
         this._pendingChunks.set(meta.fileId, pending);
       }
-      pending.push({ key, val: new Uint8Array(val) });
+      pending.push({ meta, val: new Uint8Array(val) });
       return;
     }
 
-    await this._writeChunk(file, meta, val);
+    await this._writeChunkRun(file, [{ meta, val }]);
+  }
+
+  async _handleChunks(items) {
+    if (!items || items.length === 0) return;
+
+    // Group items by fileId
+    const groups = new Map();
+    for (const item of items) {
+      const meta = item.meta || unpackChunkMeta(item.key);
+      let list = groups.get(meta.fileId);
+      if (!list) {
+        list = [];
+        groups.set(meta.fileId, list);
+      }
+      list.push({ meta, val: item.val });
+    }
+
+    for (const [fileId, chunkList] of groups.entries()) {
+      const file = this.activeFiles.get(fileId);
+      if (!file) {
+        if (this.completedFiles.has(fileId)) {
+          continue;
+        }
+        let pending = this._pendingChunks.get(fileId);
+        if (!pending) {
+          pending = [];
+          this._pendingChunks.set(fileId, pending);
+        }
+        for (const c of chunkList) {
+          pending.push({ meta: c.meta, val: new Uint8Array(c.val) });
+        }
+        continue;
+      }
+
+      await this._writeChunkRun(file, chunkList);
+    }
   }
 
   async _writeChunk(file, meta, val) {
-    // Idempotency / resume hit check
-    if (file.resumeState.isVerified(meta.chunkIndex)) {
+    return this._writeChunkRun(file, [{ meta, val }]);
+  }
+
+  async _writeChunkRun(file, items) {
+    if (!items || items.length === 0) return;
+
+    // 1. Unpack, verify CRC, and filter out resume hits
+    const toWrite = [];
+    for (const item of items) {
+      const meta = item.meta || unpackChunkMeta(item.key);
+      const val = item.val;
+
+      // Idempotency / resume hit check
+      if (file.resumeState.isVerified(meta.chunkIndex)) {
+        if (this.metrics) {
+          this.metrics.resumeHits++;
+          this.metrics.chunksVerified++;
+        }
+        continue;
+      }
+
+      // Per-chunk corruption detection
+      const t0 = Date.now();
+      const computedCrc = crc32(val);
       if (this.metrics) {
-        this.metrics.resumeHits++;
-        this.metrics.chunksVerified++;
+        this.metrics.checksumTimeMs += (Date.now() - t0);
       }
-      return;
-    }
 
-    // Per-chunk corruption detection
-    const t0 = Date.now();
-    const computedCrc = crc32(val);
-    if (this.metrics) {
-      this.metrics.checksumTimeMs += (Date.now() - t0);
+      if (computedCrc !== meta.checksum) {
+        throw new Error(
+          `Chunk ${meta.chunkIndex} corruption: CRC 0x${computedCrc.toString(16)} !== 0x${meta.checksum.toString(16)}`
+        );
+      }
+
+      toWrite.push({ meta, val });
     }
 
-    if (computedCrc !== meta.checksum) {
-      throw new Error(
-        `Chunk ${meta.chunkIndex} corruption: CRC 0x${computedCrc.toString(16)} !== 0x${meta.checksum.toString(16)}`
-      );
+    if (toWrite.length === 0) {
+      if (file.pendingEnd && (file.fileSize === 0 || file.resumeState.isComplete())) {
+        await this._finalizeFile(file);
+      }
+      return;
     }
 
-    // Artificial write delay for slow-receiver backpressure tests
-    if (this.writeDelayMs > 0) {
-      await new Promise((r) => setTimeout(r, this.writeDelayMs));
+    // 2. Sort by offset to form maximal contiguous runs
+    toWrite.sort((a, b) => (a.meta.offset < b.meta.offset ? -1 : (a.meta.offset > b.meta.offset ? 1 : 0)));
+
+    let currentRun = [toWrite[0]];
+    let currentStartOffset = Number(toWrite[0].meta.offset);
+    let expectedNextOffset = currentStartOffset + toWrite[0].meta.length;
+
+    const flushRun = async (run, startOffset) => {
+      // Artificial write delay for slow-receiver backpressure tests
+      if (this.writeDelayMs > 0) {
+        await new Promise((r) => setTimeout(r, this.writeDelayMs));
+      }
+
+      const writeStart = Date.now();
+      let runBytes = 0;
+      for (let i = 0; i < run.length; i++) {
+        runBytes += run[i].meta.length;
+      }
+
+      if (run.length === 1) {
+        const item = run[0];
+        await file.fileHandle.write(item.val, 0, item.meta.length, Number(item.meta.offset));
+      } else {
+        const bufs = new Array(run.length);
+        for (let i = 0; i < run.length; i++) {
+          bufs[i] = run[i].val;
+        }
+        await file.fileHandle.writev(bufs, startOffset);
+      }
+
+      if (this.metrics) {
+        this.metrics.diskWriteTimeMs += (Date.now() - writeStart);
+        this.metrics.fileBytesWritten += runBytes;
+        this.metrics.chunksCreated += run.length;
+        this.metrics.chunksVerified += run.length;
+      }
+
+      for (let i = 0; i < run.length; i++) {
+        file.resumeState.markVerified(run[i].meta.chunkIndex);
+        file.chunksWrittenSinceSave++;
+      }
+    };
+
+    for (let i = 1; i < toWrite.length; i++) {
+      const item = toWrite[i];
+      const itemOffset = Number(item.meta.offset);
+
+      if (itemOffset === expectedNextOffset) {
+        currentRun.push(item);
+        expectedNextOffset = itemOffset + item.meta.length;
+      } else {
+        await flushRun(currentRun, currentStartOffset);
+        currentRun = [item];
+        currentStartOffset = itemOffset;
+        expectedNextOffset = itemOffset + item.meta.length;
+      }
     }
 
-    // Direct random-access write at specific byte offset
-    const writeStart = Date.now();
-    await file.fileHandle.write(val, 0, meta.length, Number(meta.offset));
-    if (this.metrics) {
-      this.metrics.diskWriteTimeMs += (Date.now() - writeStart);
-      this.metrics.fileBytesWritten += meta.length;
-      this.metrics.chunksCreated++;
-      this.metrics.chunksVerified++;
+    if (currentRun.length > 0) {
+      await flushRun(currentRun, currentStartOffset);
     }
 
+    // 3. Update progress reporter
     if (this.progress) {
       const diskTimeSec = Math.max(0.001, (this.metrics ? this.metrics.diskWriteTimeMs : 1) / 1000);
       const writtenMB = (this.metrics ? this.metrics.fileBytesWritten : 0) / (1024 * 1024);
       const diskMBs = Number((writtenMB / diskTimeSec).toFixed(1));
-      file.maxChunkSize = Math.max(file.maxChunkSize || 0, meta.length);
+      for (const item of toWrite) {
+        file.maxChunkSize = Math.max(file.maxChunkSize || 0, item.meta.length);
+      }
       const realTotalChunks = file.maxChunkSize > 0 && file.fileSize > 0 ? Math.ceil(file.fileSize / file.maxChunkSize) : 0;
       this.progress.update({
         fileName: file.relativePath,
@@ -326,27 +501,56 @@ export class ReceiverPipeline {
       });
     }
 
-    file.resumeState.markVerified(meta.chunkIndex);
-    file.chunksWrittenSinceSave++;
+    // 4. Trigger debounced state save
+    this._triggerStateSave(file);
 
-    if (file.chunksWrittenSinceSave >= 32) {
-      file.chunksWrittenSinceSave = 0;
-      await file.resumeState.save(file.statePath);
-    }
-
-    // If FILE_END arrived earlier while chunks were still arriving
+    // 5. If FILE_END arrived earlier while chunks were still arriving
     if (file.pendingEnd && (file.fileSize === 0 || file.resumeState.isComplete())) {
       await this._finalizeFile(file);
-      if (this._pendingTransferEnd && this.activeFiles.size === 0) {
-        this._finishTransfer();
-      }
+    }
+  }
+
+  _triggerStateSave(file, force = false) {
+    const now = Date.now();
+    const elapsed = now - file.lastStateSaveTime;
+    const shouldSave = force || file.chunksWrittenSinceSave >= 128 || (file.chunksWrittenSinceSave >= 16 && elapsed >= 1500);
+    if (!shouldSave) return;
+
+    if (file._stateSaving) {
+      file._pendingStateSave = true;
+      return;
+    }
+
+    file.chunksWrittenSinceSave = 0;
+    file.lastStateSaveTime = now;
+    file._stateSaving = true;
+
+    file.resumeState.save(file.statePath)
+      .catch(() => {})
+      .finally(() => {
+        file._stateSaving = false;
+        if (file._pendingStateSave) {
+          file._pendingStateSave = false;
+          this._triggerStateSave(file, true);
+        }
+      });
+  }
+
+  async _drainFileStateSave(file) {
+    while (file._stateSaving) {
+      await new Promise((r) => setTimeout(r, 5));
     }
   }
 
   async _handleFileEnd(key) {
     const meta = unpackFileEnd(key);
     const file = this.activeFiles.get(meta.fileId);
-    if (!file) return;
+    if (!file) {
+      if (!this.completedFiles.has(meta.fileId)) {
+        this._pendingFileEnds.set(meta.fileId, meta);
+      }
+      return;
+    }
 
     if (meta.sha256) {
       file.sha256 = meta.sha256;
@@ -354,9 +558,6 @@ export class ReceiverPipeline {
 
     if (file.fileSize === 0 || file.resumeState.isComplete()) {
       await this._finalizeFile(file);
-      if (this._pendingTransferEnd && this.activeFiles.size === 0) {
-        this._finishTransfer();
-      }
     } else {
       file.pendingEnd = true;
       file.endMeta = meta;
@@ -364,6 +565,9 @@ export class ReceiverPipeline {
   }
 
   async _finalizeFile(file) {
+    // Await any in-flight background state save before final save
+    await this._drainFileStateSave(file);
+
     // Save final state before rename
     await file.resumeState.save(file.statePath);
 
@@ -388,10 +592,20 @@ export class ReceiverPipeline {
     this.activeFiles.delete(file.fileId);
     this.completedFiles.add(file.fileId);
     this.completedFiles.add(file.destPath);
+    this._completedFileCount++;
+
+    this._checkTransferCompletion();
   }
 
   async close() {
     for (const [fileId, file] of this.activeFiles.entries()) {
+      await this._drainFileStateSave(file);
+      if (file.chunksWrittenSinceSave > 0) {
+        try {
+          await file.resumeState.save(file.statePath);
+        } catch {}
+        file.chunksWrittenSinceSave = 0;
+      }
       if (file.fileHandle) {
         try {
           await file.fileHandle.close();
@@ -401,6 +615,7 @@ export class ReceiverPipeline {
     }
     this.activeFiles.clear();
     this._pendingChunks.clear();
+    this._pendingFileEnds.clear();
   }
 
   async _computeFileSha256(filePath) {

package/src/sender/pipeline.js

@@ -20,6 +20,25 @@ import {
 import { extractGenerationBuffers } from '../core/generation.js';
 import { FileResumeState } from '../resume/state.js';
 
+/**
+ * Reusable bump allocator that returns its ArrayBuffer to a pool upon reset/release.
+ */
+class PooledBumpAllocator extends BumpAllocator {
+  constructor(capacity, pool = null) {
+    super(capacity);
+    this._pool = pool;
+  }
+
+  reset() {
+    super.reset();
+    if (this._pool && this._pool.length < 16 && !this._pool.includes(this)) {
+      this._pool.push(this);
+    }
+  }
+}
+
+const defaultAllocatorPool = [];
+
 class RaptiyeSink extends Sink {
   /**
    * @param {import('raptiye').ReplicationPipeline} replication
@@ -104,11 +123,13 @@ export class SenderPipeline {
     this.chunkSize = options.chunkSize || 1024 * 1024;
     this.maxEntries = options.maxEntries || 8;
     this.maxBytes = options.maxBytes || 8 * 1024 * 1024;
-    this.maxImmutableBuffers = options.maxImmutableBuffers || 8;
-    this.maxConcurrentFlushes = options.maxConcurrentFlushes || Math.min(this.maxImmutableBuffers, 8);
+    this.maxImmutableBuffers = options.maxImmutableBuffers || 32;
+    this.maxConcurrentFlushes = options.maxConcurrentFlushes || Math.min(this.maxImmutableBuffers, 32);
     this.metrics = metrics;
     this.progress = progress;
     this.knownResumeState = knownResumeState;
+    this._allocatorPool = options.allocatorPool || defaultAllocatorPool;
+    this._readScratch = null;
 
     this.transferId = crypto.randomUUID();
 
@@ -119,10 +140,22 @@ export class SenderPipeline {
     this.sink = new RaptiyeSink(this.replication, this.metrics, this.progress);
     this.engine = new MutationEngine({
       sink: this.sink,
-      createStore: () => new ArenaStore({
-        chunkSize: Math.max(64, this.maxEntries),
-        allocator: new BumpAllocator(arenaCapacity)
-      }),
+      createStore: () => {
+        let allocator = null;
+        if (this._allocatorPool && this._allocatorPool.length > 0) {
+          const idx = this._allocatorPool.findIndex((a) => a.capacity >= arenaCapacity);
+          if (idx !== -1) {
+            allocator = this._allocatorPool.splice(idx, 1)[0];
+          }
+        }
+        if (!allocator) {
+          allocator = new PooledBumpAllocator(arenaCapacity, this._allocatorPool);
+        }
+        return new ArenaStore({
+          chunkSize: Math.max(64, this.maxEntries),
+          allocator
+        });
+      },
       maxEntries: this.maxEntries,
       maxBytes: this.maxBytes,
       maxImmutableBuffers: this.maxImmutableBuffers,
@@ -148,6 +181,7 @@ export class SenderPipeline {
 
   async abort() {
     this.aborted = true;
+    this._readScratch = null;
     for (const waiter of this._abortWaiters) {
       waiter();
     }
@@ -233,7 +267,8 @@ export class SenderPipeline {
         fileId: file.fileId,
         fileSize: file.size,
         path: file.relativePath,
-        sha256: file.sha256 || ''
+        sha256: file.sha256 || '',
+        chunkSize: this.chunkSize
       });
       await this._append(Opcodes.FILE_BEGIN, fbegin);
 
@@ -263,8 +298,14 @@ export class SenderPipeline {
               continue;
             }
 
-            // Direct read into fresh chunk buffer
-            const chunkBuf = new Uint8Array(chunkLen);
+            // Direct read into reusable chunk buffer (Muttafa copies synchronously into its arena on append)
+            if (!this._readScratch || this._readScratch.byteLength < chunkLen) {
+              this._readScratch = new Uint8Array(Math.max(this.chunkSize, chunkLen));
+            }
+            const chunkBuf = (chunkLen === this._readScratch.byteLength)
+              ? this._readScratch
+              : this._readScratch.subarray(0, chunkLen);
+
             const readStart = Date.now();
             await handle.read(chunkBuf, 0, chunkLen, Number(offset));
             if (this.metrics) {
@@ -339,5 +380,6 @@ export class SenderPipeline {
       });
       this.progress.stop();
     }
+    this._readScratch = null;
   }
 }