|
| 1 | +/** |
| 2 | + * @license |
| 3 | + * Copyright Google LLC All Rights Reserved. |
| 4 | + * |
| 5 | + * Use of this source code is governed by an MIT-style license that can be |
| 6 | + * found in the LICENSE file at https://angular.io/license |
| 7 | + */ |
| 8 | + |
| 9 | +import type { CompilerOptions } from '@angular/compiler-cli'; |
| 10 | +import type { PartialMessage } from 'esbuild'; |
| 11 | +import { createRequire } from 'node:module'; |
| 12 | +import { MessageChannel } from 'node:worker_threads'; |
| 13 | +import Piscina from 'piscina'; |
| 14 | +import type { SourceFile } from 'typescript'; |
| 15 | +import type { AngularHostOptions } from '../angular-host'; |
| 16 | +import { AngularCompilation, EmitFileResult } from './angular-compilation'; |
| 17 | + |
| 18 | +/** |
| 19 | + * An Angular compilation which uses a Node.js Worker thread to load and execute |
| 20 | + * the TypeScript and Angular compilers. This allows for longer synchronous actions |
| 21 | + * such as semantic and template diagnostics to be calculated in parallel to the |
| 22 | + * other aspects of the application bundling process. The worker thread also has |
| 23 | + * a separate memory pool which significantly reduces the need for adjusting the |
| 24 | + * main Node.js CLI process memory settings with large application code sizes. |
| 25 | + */ |
| 26 | +export class ParallelCompilation extends AngularCompilation { |
| 27 | + readonly #worker: Piscina; |
| 28 | + |
| 29 | + constructor(readonly jit: boolean) { |
| 30 | + super(); |
| 31 | + |
| 32 | + // TODO: Convert to import.meta usage during ESM transition |
| 33 | + const localRequire = createRequire(__filename); |
| 34 | + |
| 35 | + this.#worker = new Piscina({ |
| 36 | + minThreads: 1, |
| 37 | + maxThreads: 1, |
| 38 | + idleTimeout: Infinity, |
| 39 | + filename: localRequire.resolve('./parallel-worker'), |
| 40 | + }); |
| 41 | + } |
| 42 | + |
| 43 | + override initialize( |
| 44 | + tsconfig: string, |
| 45 | + hostOptions: AngularHostOptions, |
| 46 | + compilerOptionsTransformer?: |
| 47 | + | ((compilerOptions: CompilerOptions) => CompilerOptions) |
| 48 | + | undefined, |
| 49 | + ): Promise<{ |
| 50 | + affectedFiles: ReadonlySet<SourceFile>; |
| 51 | + compilerOptions: CompilerOptions; |
| 52 | + referencedFiles: readonly string[]; |
| 53 | + }> { |
| 54 | + const stylesheetChannel = new MessageChannel(); |
| 55 | + // The request identifier is required because Angular can issue multiple concurrent requests |
| 56 | + stylesheetChannel.port1.on('message', ({ requestId, data, containingFile, stylesheetFile }) => { |
| 57 | + hostOptions |
| 58 | + .transformStylesheet(data, containingFile, stylesheetFile) |
| 59 | + .then((value) => stylesheetChannel.port1.postMessage({ requestId, value })) |
| 60 | + .catch((error) => stylesheetChannel.port1.postMessage({ requestId, error })); |
| 61 | + }); |
| 62 | + |
| 63 | + // The web worker processing is a synchronous operation and uses shared memory combined with |
| 64 | + // the Atomics API to block execution here until a response is received. |
| 65 | + const webWorkerChannel = new MessageChannel(); |
| 66 | + const webWorkerSignal = new Int32Array(new SharedArrayBuffer(4)); |
| 67 | + webWorkerChannel.port1.on('message', ({ workerFile, containingFile }) => { |
| 68 | + try { |
| 69 | + const workerCodeFile = hostOptions.processWebWorker(workerFile, containingFile); |
| 70 | + webWorkerChannel.port1.postMessage({ workerCodeFile }); |
| 71 | + } catch (error) { |
| 72 | + webWorkerChannel.port1.postMessage({ error }); |
| 73 | + } finally { |
| 74 | + Atomics.store(webWorkerSignal, 0, 1); |
| 75 | + Atomics.notify(webWorkerSignal, 0); |
| 76 | + } |
| 77 | + }); |
| 78 | + |
| 79 | + // The compiler options transformation is a synchronous operation and uses shared memory combined |
| 80 | + // with the Atomics API to block execution here until a response is received. |
| 81 | + const optionsChannel = new MessageChannel(); |
| 82 | + const optionsSignal = new Int32Array(new SharedArrayBuffer(4)); |
| 83 | + optionsChannel.port1.on('message', (compilerOptions) => { |
| 84 | + try { |
| 85 | + const transformedOptions = compilerOptionsTransformer?.(compilerOptions) ?? compilerOptions; |
| 86 | + optionsChannel.port1.postMessage({ transformedOptions }); |
| 87 | + } catch (error) { |
| 88 | + webWorkerChannel.port1.postMessage({ error }); |
| 89 | + } finally { |
| 90 | + Atomics.store(optionsSignal, 0, 1); |
| 91 | + Atomics.notify(optionsSignal, 0); |
| 92 | + } |
| 93 | + }); |
| 94 | + |
| 95 | + // Execute the initialize function in the worker thread |
| 96 | + return this.#worker.run( |
| 97 | + { |
| 98 | + fileReplacements: hostOptions.fileReplacements, |
| 99 | + tsconfig, |
| 100 | + jit: this.jit, |
| 101 | + stylesheetPort: stylesheetChannel.port2, |
| 102 | + optionsPort: optionsChannel.port2, |
| 103 | + optionsSignal, |
| 104 | + webWorkerPort: webWorkerChannel.port2, |
| 105 | + webWorkerSignal, |
| 106 | + }, |
| 107 | + { |
| 108 | + name: 'initialize', |
| 109 | + transferList: [stylesheetChannel.port2, optionsChannel.port2, webWorkerChannel.port2], |
| 110 | + }, |
| 111 | + ); |
| 112 | + } |
| 113 | + |
| 114 | + /** |
| 115 | + * This is not needed with this compilation type since the worker will already send a response |
| 116 | + * with the serializable esbuild compatible diagnostics. |
| 117 | + */ |
| 118 | + protected override collectDiagnostics(): never { |
| 119 | + throw new Error('Not implemented in ParallelCompilation.'); |
| 120 | + } |
| 121 | + |
| 122 | + override diagnoseFiles(): Promise<{ errors?: PartialMessage[]; warnings?: PartialMessage[] }> { |
| 123 | + return this.#worker.run(undefined, { name: 'diagnose' }); |
| 124 | + } |
| 125 | + |
| 126 | + override emitAffectedFiles(): Promise<Iterable<EmitFileResult>> { |
| 127 | + return this.#worker.run(undefined, { name: 'emit' }); |
| 128 | + } |
| 129 | + |
| 130 | + override update(files: Set<string>): Promise<void> { |
| 131 | + return this.#worker.run(files, { name: 'update' }); |
| 132 | + } |
| 133 | + |
| 134 | + override close() { |
| 135 | + // Workaround piscina bug where a worker thread will be recreated after destroy to meet the minimum. |
| 136 | + this.#worker.options.minThreads = 0; |
| 137 | + |
| 138 | + return this.#worker.destroy(); |
| 139 | + } |
| 140 | +} |
0 commit comments