@parcel/workers 2.7.0 → 2.8.1

package/lib/Worker.js

@@ -43,7 +43,7 @@ let WORKER_ID = 0;
 
 class Worker extends _events().default {
   id = WORKER_ID++;
-  sharedReferences = new Map();
+  sentSharedReferences = new Set();
   calls = new Map();
   exitCode = null;
   callId = 0;
@@ -129,6 +129,7 @@ class Worker extends _events().default {
   }
 
   sendSharedReference(ref, value) {
+    this.sentSharedReferences.add(ref);
     return new Promise((resolve, reject) => {
       this.call({
         method: 'createSharedReference',

package/lib/WorkerFarm.js

@@ -114,6 +114,7 @@ class WorkerFarm extends _events().default {
   handles = new Map();
   sharedReferences = new Map();
   sharedReferencesByValue = new Map();
+  serializedSharedReferences = new Map();
 
   constructor(farmOptions = {}) {
     super();
@@ -189,19 +190,25 @@ class WorkerFarm extends _events().default {
     return this.options.maxConcurrentWorkers > 0 || !this.options.useLocalWorker;
   }
 
-  createHandle(method) {
+  createHandle(method, useMainThread = false) {
     return async (...args) => {
       // Child process workers are slow to start (~600ms).
       // While we're waiting, just run on the main thread.
       // This significantly speeds up startup time.
-      if (this.shouldUseRemoteWorkers()) {
+      if (this.shouldUseRemoteWorkers() && !useMainThread) {
         return this.addCall(method, [...args, false]);
       } else {
         if (this.options.warmWorkers && this.shouldStartRemoteWorkers()) {
           this.warmupWorker(method, args);
         }
 
-        let processedArgs = (0, _core().restoreDeserializedObject)((0, _core().prepareForSerialization)([...args, false]));
+        let processedArgs;
+
+        if (!useMainThread) {
+          processedArgs = (0, _core().restoreDeserializedObject)((0, _core().prepareForSerialization)([...args, false]));
+        } else {
+          processedArgs = args;
+        }
 
         if (this.localWorkerInit != null) {
           await this.localWorkerInit;
@@ -276,9 +283,19 @@ class WorkerFarm extends _events().default {
       }
 
       if (worker.calls.size < this.options.maxConcurrentCallsPerWorker) {
-        worker.call(this.callQueue.shift());
+        this.callWorker(worker, this.callQueue.shift());
+      }
+    }
+  }
+
+  async callWorker(worker, call) {
+    for (let ref of this.sharedReferences.keys()) {
+      if (!worker.sentSharedReferences.has(ref)) {
+        await worker.sendSharedReference(ref, this.getSerializedSharedReference(ref));
       }
     }
+
+    worker.call(call);
   }
 
   async processRequest(data, worker) {
@@ -408,30 +425,29 @@ class WorkerFarm extends _events().default {
     return handle;
   }
 
-  async createSharedReference(value, // An optional, pre-serialized representation of the value to be used
-  // in its place.
-  buffer) {
+  createSharedReference(value, isCacheable = true) {
     let ref = referenceId++;
     this.sharedReferences.set(ref, value);
     this.sharedReferencesByValue.set(value, ref);
-    let toSend = buffer ? buffer.buffer : value;
-    let promises = [];
 
-    for (let worker of this.workers.values()) {
-      if (worker.ready) {
-        promises.push(worker.sendSharedReference(ref, toSend));
-      }
+    if (!isCacheable) {
+      this.serializedSharedReferences.set(ref, null);
     }
 
-    await Promise.all(promises);
     return {
       ref,
       dispose: () => {
         this.sharedReferences.delete(ref);
         this.sharedReferencesByValue.delete(value);
+        this.serializedSharedReferences.delete(ref);
         let promises = [];
 
         for (let worker of this.workers.values()) {
+          if (!worker.sentSharedReferences.has(ref)) {
+            continue;
+          }
+
+          worker.sentSharedReferences.delete(ref);
           promises.push(new Promise((resolve, reject) => {
             worker.call({
               method: 'deleteSharedReference',
@@ -449,6 +465,24 @@ class WorkerFarm extends _events().default {
     };
   }
 
+  getSerializedSharedReference(ref) {
+    let cached = this.serializedSharedReferences.get(ref);
+
+    if (cached) {
+      return cached;
+    }
+
+    let value = this.sharedReferences.get(ref);
+    let buf = (0, _core().serialize)(value).buffer; // If the reference was created with the isCacheable option set to false,
+    // serializedSharedReferences will contain `null` as the value.
+
+    if (cached !== null) {
+      this.serializedSharedReferences.set(ref, buf);
+    }
+
+    return buf;
+  }
+
   async startProfile() {
     let promises = [];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parcel/workers",
-  "version": "2.7.0",
+  "version": "2.8.1",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "MIT",
   "publishConfig": {
@@ -21,20 +21,20 @@
     "node": ">= 12.0.0"
   },
   "dependencies": {
-    "@parcel/diagnostic": "2.7.0",
-    "@parcel/logger": "2.7.0",
-    "@parcel/types": "2.7.0",
-    "@parcel/utils": "2.7.0",
+    "@parcel/diagnostic": "2.8.1",
+    "@parcel/logger": "2.8.1",
+    "@parcel/types": "2.8.1",
+    "@parcel/utils": "2.8.1",
     "chrome-trace-event": "^1.0.2",
     "nullthrows": "^1.1.1"
   },
   "peerDependencies": {
-    "@parcel/core": "^2.7.0"
+    "@parcel/core": "^2.8.1"
   },
   "browser": {
     "./src/cpuCount.js": false,
     "./src/process/ProcessWorker.js": false,
     "./src/threads/ThreadsWorker.js": false
   },
-  "gitHead": "9e5d05586577e89991ccf90400f2c741dca11aa3"
+  "gitHead": "f8d3fc30ca5b33d8f8674525f2a741d662c5986a"
 }

package/src/Worker.js

@@ -31,7 +31,7 @@ export default class Worker extends EventEmitter {
   +options: WorkerOpts;
   worker: WorkerImpl;
   id: number = WORKER_ID++;
-  sharedReferences: $ReadOnlyMap<SharedReference, mixed> = new Map();
+  sentSharedReferences: Set<SharedReference> = new Set();
 
   calls: Map<number, WorkerCall> = new Map();
   exitCode: ?number = null;
@@ -135,6 +135,7 @@ export default class Worker extends EventEmitter {
   }
 
   sendSharedReference(ref: SharedReference, value: mixed): Promise<any> {
+    this.sentSharedReferences.add(ref);
     return new Promise((resolve, reject) => {
       this.call({
         method: 'createSharedReference',

package/src/WorkerFarm.js

@@ -76,6 +76,7 @@ export default class WorkerFarm extends EventEmitter {
   handles: Map<number, Handle> = new Map();
   sharedReferences: Map<SharedReference, mixed> = new Map();
   sharedReferencesByValue: Map<mixed, SharedReference> = new Map();
+  serializedSharedReferences: Map<SharedReference, ?ArrayBuffer> = new Map();
   profiler: ?Profiler;
 
   constructor(farmOptions: $Shape<FarmOptions> = {}) {
@@ -175,21 +176,26 @@ export default class WorkerFarm extends EventEmitter {
     );
   }
 
-  createHandle(method: string): HandleFunction {
+  createHandle(method: string, useMainThread: boolean = false): HandleFunction {
     return async (...args) => {
       // Child process workers are slow to start (~600ms).
       // While we're waiting, just run on the main thread.
       // This significantly speeds up startup time.
-      if (this.shouldUseRemoteWorkers()) {
+      if (this.shouldUseRemoteWorkers() && !useMainThread) {
         return this.addCall(method, [...args, false]);
       } else {
         if (this.options.warmWorkers && this.shouldStartRemoteWorkers()) {
           this.warmupWorker(method, args);
         }
 
-        let processedArgs = restoreDeserializedObject(
-          prepareForSerialization([...args, false]),
-        );
+        let processedArgs;
+        if (!useMainThread) {
+          processedArgs = restoreDeserializedObject(
+            prepareForSerialization([...args, false]),
+          );
+        } else {
+          processedArgs = args;
+        }
 
         if (this.localWorkerInit != null) {
           await this.localWorkerInit;
@@ -273,11 +279,24 @@ export default class WorkerFarm extends EventEmitter {
       }
 
       if (worker.calls.size < this.options.maxConcurrentCallsPerWorker) {
-        worker.call(this.callQueue.shift());
+        this.callWorker(worker, this.callQueue.shift());
       }
     }
   }
 
+  async callWorker(worker: Worker, call: WorkerCall): Promise<void> {
+    for (let ref of this.sharedReferences.keys()) {
+      if (!worker.sentSharedReferences.has(ref)) {
+        await worker.sendSharedReference(
+          ref,
+          this.getSerializedSharedReference(ref),
+        );
+      }
+    }
+
+    worker.call(call);
+  }
+
   async processRequest(
     data: {|
       location: FilePath,
@@ -400,33 +419,31 @@ export default class WorkerFarm extends EventEmitter {
     return handle;
   }
 
-  async createSharedReference(
+  createSharedReference(
     value: mixed,
-    // An optional, pre-serialized representation of the value to be used
-    // in its place.
-    buffer?: Buffer,
-  ): Promise<{|ref: SharedReference, dispose(): Promise<mixed>|}> {
+    isCacheable: boolean = true,
+  ): {|ref: SharedReference, dispose(): Promise<mixed>|} {
     let ref = referenceId++;
     this.sharedReferences.set(ref, value);
     this.sharedReferencesByValue.set(value, ref);
-
-    let toSend = buffer ? buffer.buffer : value;
-    let promises = [];
-    for (let worker of this.workers.values()) {
-      if (worker.ready) {
-        promises.push(worker.sendSharedReference(ref, toSend));
-      }
+    if (!isCacheable) {
+      this.serializedSharedReferences.set(ref, null);
     }
 
-    await Promise.all(promises);
-
     return {
       ref,
       dispose: () => {
         this.sharedReferences.delete(ref);
         this.sharedReferencesByValue.delete(value);
+        this.serializedSharedReferences.delete(ref);
+
         let promises = [];
         for (let worker of this.workers.values()) {
+          if (!worker.sentSharedReferences.has(ref)) {
+            continue;
+          }
+
+          worker.sentSharedReferences.delete(ref);
           promises.push(
             new Promise((resolve, reject) => {
               worker.call({
@@ -445,6 +462,24 @@ export default class WorkerFarm extends EventEmitter {
     };
   }
 
+  getSerializedSharedReference(ref: SharedReference): ArrayBuffer {
+    let cached = this.serializedSharedReferences.get(ref);
+    if (cached) {
+      return cached;
+    }
+
+    let value = this.sharedReferences.get(ref);
+    let buf = serialize(value).buffer;
+
+    // If the reference was created with the isCacheable option set to false,
+    // serializedSharedReferences will contain `null` as the value.
+    if (cached !== null) {
+      this.serializedSharedReferences.set(ref, buf);
+    }
+
+    return buf;
+  }
+
   async startProfile() {
     let promises = [];
     for (let worker of this.workers.values()) {