Package on main thread for small rebuilds

packages/core/core/src/PackagerRunner.js

@@ -68,6 +68,7 @@ type Opts = {|
   report: ReportFn,
   previousDevDeps: Map<string, string>,
   previousInvalidations: Array<RequestInvalidation>,
+  useFarm: boolean,
 |};
 
 export type PackageRequestResult = {|
@@ -110,20 +111,23 @@ export default class PackagerRunner {
   devDepRequests: Map<string, DevDepRequest>;
   invalidations: Map<string, RequestInvalidation>;
   previousInvalidations: Array<RequestInvalidation>;
+  useFarm: boolean;
 
   constructor({
     config,
     options,
     report,
     previousDevDeps,
     previousInvalidations,
+    useFarm,
   }: Opts) {
     this.config = config;
     this.options = options;
     this.report = report;
     this.previousDevDeps = previousDevDeps;
     this.devDepRequests = new Map();
     this.previousInvalidations = previousInvalidations;
+    this.useFarm = useFarm;
     this.invalidations = new Map();
     this.pluginOptions = new PluginOptions(
       optionsProxy(this.options, option => {
@@ -386,6 +390,19 @@ export default class PackagerRunner {
     bundleConfigs: Map<string, Config>,
   ): Promise<BundleResult> {
     let bundle = NamedBundle.get(internalBundle, bundleGraph, this.options);
+    let publicBundleGraph = new BundleGraph<NamedBundleType>(
+      bundleGraph,
+      NamedBundle.get.bind(NamedBundle),
+      this.options,
+    );
+
+    if (this.useFarm) {
+      this.report({
+        type: 'bundleGraph',
+        bundleGraph: publicBundleGraph,
+      });
+    }
+
     this.report({
       type: 'buildProgress',
       phase: 'packaging',
@@ -399,11 +416,7 @@ export default class PackagerRunner {
         config: configs.get(name)?.result,
         bundleConfig: bundleConfigs.get(name)?.result,
         bundle,
-        bundleGraph: new BundleGraph<NamedBundleType>(
-          bundleGraph,
-          NamedBundle.get.bind(NamedBundle),
-          this.options,
-        ),
+        bundleGraph: publicBundleGraph,
         getSourceMapReference: map => {
           return this.getSourceMapReference(bundle, map);
         },
@@ -482,6 +495,13 @@ export default class PackagerRunner {
       return {type: bundle.type, contents, map};
     }
 
+    if (this.useFarm) {
+      this.report({
+        type: 'bundleGraph',
+        bundleGraph,
+      });
+    }
+
     this.report({
       type: 'buildProgress',
       phase: 'optimizing',

packages/core/core/src/ReporterRunner.js

@@ -21,6 +21,7 @@ import logger, {
 } from '@parcel/logger';
 import PluginOptions from './public/PluginOptions';
 import BundleGraph from './BundleGraph';
+import {bundleGraphToInternalBundleGraph} from './public/BundleGraph';
 
 type Opts = {|
   config: ParcelConfig,
@@ -34,6 +35,7 @@ export default class ReporterRunner {
   options: ParcelOptions;
   pluginOptions: PluginOptions;
   reporters: Array<LoadedPlugin<Reporter>>;
+  bundleGraph: BundleGraph;
 
   constructor(opts: Opts) {
     this.config = opts.config;
@@ -53,7 +55,9 @@ export default class ReporterRunner {
   }
 
   eventHandler: ReporterEvent => void = (event): void => {
-    if (
+    if (event.type === 'bundleGraph') {
+      this.bundleGraph = bundleGraphToInternalBundleGraph(event.bundleGraph);
+    } else if (
       event.type === 'buildProgress' &&
       (event.phase === 'optimizing' || event.phase === 'packaging') &&
       !(event.bundle instanceof NamedBundle)
@@ -64,10 +68,12 @@ export default class ReporterRunner {
       let bundle: InternalBundle = event.bundle;
       // Convert any internal bundles back to their public equivalents as reporting
       // is public api
-      let bundleGraph = this.workerFarm.workerApi.getSharedReference(
-        // $FlowFixMe
-        bundleGraphRef,
-      );
+      let bundleGraph =
+        this.bundleGraph ??
+        this.workerFarm.workerApi.getSharedReference(
+          // $FlowFixMe
+          bundleGraphRef,
+        );
       invariant(bundleGraph instanceof BundleGraph);
       // $FlowFixMe[incompatible-call]
       this.report({
@@ -131,5 +137,17 @@ export function reportWorker(workerApi: WorkerApi, event: ReporterEvent) {
 }
 
 export function report(event: ReporterEvent) {
-  bus.emit('reporterEvent', event);
+  if (
+    event.bundleGraph &&
+    event.type === 'buildProgress' &&
+    (event.phase === 'optimizing' || event.phase === 'packaging')
+  ) {
+    bus.emit('reporterEvent', {
+      ...event,
+      bundle: bundleToInternalBundle(event.bundle),
+      bundleGraphRef: event.bundleGraph,
+    });
+  } else {
+    bus.emit('reporterEvent', event);
+  }
 }

packages/core/core/src/requests/PackageRequest.js

@@ -18,8 +18,9 @@ import createParcelConfigRequest from './ParcelConfigRequest';
 type PackageRequestInput = {|
   bundleGraph: BundleGraph,
   bundle: Bundle,
-  bundleGraphReference: SharedReference,
+  bundleGraphReference?: SharedReference,
   optionsRef: SharedReference,
+  shouldSerialize?: boolean,
 |};
 
 type RunInput = {|
@@ -46,18 +47,20 @@ export function createPackageRequest(
 }
 
 async function run({input, api, farm}: RunInput) {
-  let {bundleGraphReference, optionsRef, bundle} = input;
-  let runPackage = farm.createHandle('runPackage');
+  let {bundleGraphReference, optionsRef, bundle, shouldSerialize} = input;
+  let runPackage = farm.createHandle('runPackage', shouldSerialize);
 
   let start = Date.now();
   let {devDeps, invalidDevDeps} = await getDevDepRequests(api);
   let {cachePath} = nullthrows(
     await api.runRequest<null, ConfigAndCachePath>(createParcelConfigRequest()),
   );
+
   let {devDepRequests, configRequests, bundleInfo, invalidations} =
     (await runPackage({
       bundle,
-      bundleGraphReference,
+      bundleGraphReference:
+        bundleGraphReference == null ? input.bundleGraph : bundleGraphReference,
       optionsRef,
       configCachePath: cachePath,
       previousDevDeps: devDeps,

packages/core/core/src/requests/WriteBundlesRequest.js

@@ -49,10 +49,6 @@ export default function createWriteBundlesRequest(
 
 async function run({input, api, farm, options}: RunInput) {
   let {bundleGraph, optionsRef} = input;
-  let {ref, dispose} = await farm.createSharedReference(
-    bundleGraph,
-    serialize(bundleGraph),
-  );
 
   api.invalidateOnOptionChange('shouldContentHash');
 
@@ -83,6 +79,23 @@ async function run({input, api, farm, options}: RunInput) {
     return true;
   });
 
+  let ref;
+  let dispose;
+
+  // Create shared reference in WorkerFarm if we need to change multiple bundles and if we
+  // can't skip the subrequests for all the bundles
+  let shouldSerialize = false;
+  if (
+    bundles.length > 1 &&
+    bundles.filter(b => !api.canSkipSubrequest(bundleGraph.getHash(b))).length >
+      1
+  ) {
+    shouldSerialize = true;
+    ({ref, dispose} = await farm.createSharedReference(
+      bundleGraph,
+      serialize(bundleGraph),
+    ));
+  }
   try {
     await Promise.all(
       bundles.map(async bundle => {
@@ -91,6 +104,7 @@ async function run({input, api, farm, options}: RunInput) {
           bundleGraph,
           bundleGraphReference: ref,
           optionsRef,
+          shouldSerialize,
         });
 
         let info = await api.runRequest(request);
@@ -134,7 +148,9 @@ async function run({input, api, farm, options}: RunInput) {
     api.storeResult(res);
     return res;
   } finally {
-    await dispose();
+    if (dispose) {
+      await dispose();
+    }
   }
 }
 

packages/core/core/src/worker.js

@@ -17,7 +17,7 @@ import Transformation, {
   type TransformationOpts,
   type TransformationResult,
 } from './Transformation';
-import {reportWorker} from './ReporterRunner';
+import {reportWorker, report} from './ReporterRunner';
 import PackagerRunner, {type PackageRequestResult} from './PackagerRunner';
 import Validation, {type ValidationOpts} from './Validation';
 import ParcelConfig from './ParcelConfig';
@@ -121,25 +121,32 @@ export async function runPackage(
     previousInvalidations,
   }: {|
     bundle: Bundle,
-    bundleGraphReference: SharedReference,
+    bundleGraphReference: SharedReference | BundleGraph,
     configCachePath: string,
     optionsRef: SharedReference,
     previousDevDeps: Map<string, string>,
     invalidDevDeps: Array<DevDepSpecifier>,
     previousInvalidations: Array<RequestInvalidation>,
   |},
 ): Promise<PackageRequestResult> {
-  let bundleGraph = workerApi.getSharedReference(bundleGraphReference);
+  let bundleGraph =
+    typeof bundleGraphReference === 'number'
+      ? workerApi.getSharedReference(bundleGraphReference)
+      : bundleGraphReference;
   invariant(bundleGraph instanceof BundleGraph);
   let options = loadOptions(optionsRef, workerApi);
   let parcelConfig = await loadConfig(configCachePath, options);
 
   let runner = new PackagerRunner({
     config: parcelConfig,
     options,
-    report: reportWorker.bind(null, workerApi),
+    report:
+      typeof bundleGraphReference === 'number'
+        ? reportWorker.bind(null, workerApi)
+        : report,
     previousDevDeps,
     previousInvalidations,
+    useFarm: typeof bundleGraphReference === 'number' ? true : false,
   });
 
   return runner.run(bundleGraph, bundle, invalidDevDeps);

packages/core/types/index.js

@@ -1709,7 +1709,11 @@ export type TextLogEvent = {|
 /**
  * @section reporter
  */
-export type LogEvent = ProgressLogEvent | DiagnosticLogEvent | TextLogEvent;
+export type LogEvent =
+  | ProgressLogEvent
+  | DiagnosticLogEvent
+  | TextLogEvent
+  | BundleGraphEvent;
 
 /**
  * The build just started.
@@ -1764,6 +1768,11 @@ export type BundlingProgressEvent = {|
   +phase: 'bundling',
 |};
 
+export type BundleGraphEvent = {|
+  +type: 'bundleGraph',
+  +bundleGraph: BundleGraph<NamedBundle>,
+|};
+
 /**
  * A new Bundle is being packaged.
  * @section reporter
@@ -1840,7 +1849,8 @@ export type ReporterEvent =
   | BuildFailureEvent
   | WatchStartEvent
   | WatchEndEvent
-  | ValidationEvent;
+  | ValidationEvent
+  | BundleGraphEvent;
 
 /**
  * @section reporter

packages/core/workers/src/WorkerFarm.js

@@ -175,21 +175,29 @@ export default class WorkerFarm extends EventEmitter {
     );
   }
 
-  createHandle(method: string): HandleFunction {
+  createHandle(
+    method: string,
+    shouldSerialize: boolean = true,
+  ): 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() && shouldSerialize) {
         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 (shouldSerialize) {
+          processedArgs = restoreDeserializedObject(
+            prepareForSerialization([...args, false]),
+          );
+        } else {
+          processedArgs = args;
+        }
 
         if (this.localWorkerInit != null) {
           await this.localWorkerInit;