mirror of
https://github.com/angular/angular
synced 2026-05-24 09:28:37 +00:00
e36e6c85ef
`ngcc` supports both synchronous and asynchronous execution. The default mode when using `ngcc` programmatically (which is how `@angular/cli` is using it) is synchronous. When running `ngcc` from the command line (i.e. via the `ivy-ngcc` script), it runs in async mode. Previously, the work would be executed in the same way in both modes. This commit improves the performance of `ngcc` in async mode by processing tasks in parallel on multiple processes. It uses the Node.js built-in [`cluster` module](https://nodejs.org/api/cluster.html) to launch a cluster of Node.js processes and take advantage of multi-core systems. Preliminary comparisons indicate a 1.8x to 2.6x speed improvement when processing the angular.io app (apparently depending on the OS, number of available cores, system load, etc.). Further investigation is needed to better understand these numbers and identify potential areas of improvement. Inspired by/Based on @alxhub's prototype: alxhub/angular@cb631bdb1 Original design doc: https://hackmd.io/uYG9CJrFQZ-6FtKqpnYJAA?view Jira issue: [FW-1460](https://angular-team.atlassian.net/browse/FW-1460) PR Close #32427
123 lines
4.4 KiB
TypeScript
123 lines
4.4 KiB
TypeScript
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
|
|
import {EntryPoint, EntryPointJsonProperty, JsonObject} from '../packages/entry_point';
|
|
import {PartiallyOrderedList} from '../utils';
|
|
|
|
|
|
/**
|
|
* The type of the function that analyzes entry-points and creates the list of tasks.
|
|
*
|
|
* @return A list of tasks that need to be executed in order to process the necessary format
|
|
* properties for all entry-points.
|
|
*/
|
|
export type AnalyzeEntryPointsFn = () => TaskQueue;
|
|
|
|
/** The type of the function that can process/compile a task. */
|
|
export type CompileFn = (task: Task) => void;
|
|
|
|
/** The type of the function that creates the `CompileFn` function used to process tasks. */
|
|
export type CreateCompileFn = (onTaskCompleted: TaskCompletedCallback) => CompileFn;
|
|
|
|
/**
|
|
* A class that orchestrates and executes the required work (i.e. analyzes the entry-points,
|
|
* processes the resulting tasks, does book-keeping and validates the final outcome).
|
|
*/
|
|
export interface Executor {
|
|
execute(analyzeEntryPoints: AnalyzeEntryPointsFn, createCompileFn: CreateCompileFn):
|
|
void|Promise<void>;
|
|
}
|
|
|
|
/**
|
|
* Represents a partially ordered list of tasks.
|
|
*
|
|
* The ordering/precedence of tasks is determined by the inter-dependencies between their associated
|
|
* entry-points. Specifically, the tasks' order/precedence is such that tasks associated to
|
|
* dependent entry-points always come after tasks associated with their dependencies.
|
|
*
|
|
* As result of this ordering, it is guaranteed that - by processing tasks in the order in which
|
|
* they appear in the list - a task's dependencies will always have been processed before processing
|
|
* the task itself.
|
|
*
|
|
* See `DependencyResolver#sortEntryPointsByDependency()`.
|
|
*/
|
|
export type PartiallyOrderedTasks = PartiallyOrderedList<Task>;
|
|
|
|
/** Represents a unit of work: processing a specific format property of an entry-point. */
|
|
export interface Task extends JsonObject {
|
|
/** The `EntryPoint` which needs to be processed as part of the task. */
|
|
entryPoint: EntryPoint;
|
|
|
|
/**
|
|
* The `package.json` format property to process (i.e. the property which points to the file that
|
|
* is the program entry-point).
|
|
*/
|
|
formatProperty: EntryPointJsonProperty;
|
|
|
|
/**
|
|
* The list of all format properties (including `task.formatProperty`) that should be marked as
|
|
* processed once the taksk has been completed, because they point to the format-path that will be
|
|
* processed as part of the task.
|
|
*/
|
|
formatPropertiesToMarkAsProcessed: EntryPointJsonProperty[];
|
|
|
|
/** Whether to also process typings for this entry-point as part of the task. */
|
|
processDts: boolean;
|
|
}
|
|
|
|
/** A function to be called once a task has been processed. */
|
|
export type TaskCompletedCallback = (task: Task, outcome: TaskProcessingOutcome) => void;
|
|
|
|
/** Represents the outcome of processing a `Task`. */
|
|
export const enum TaskProcessingOutcome {
|
|
/** The target format property was already processed - didn't have to do anything. */
|
|
AlreadyProcessed,
|
|
|
|
/** Successfully processed the target format property. */
|
|
Processed,
|
|
}
|
|
|
|
/**
|
|
* A wrapper around a list of tasks and providing utility methods for getting the next task of
|
|
* interest and determining when all tasks have been completed.
|
|
*
|
|
* (This allows different implementations to impose different constraints on when a task's
|
|
* processing can start.)
|
|
*/
|
|
export interface TaskQueue {
|
|
/** Whether all tasks have been completed. */
|
|
allTasksCompleted: boolean;
|
|
|
|
/**
|
|
* Get the next task whose processing can start (if any).
|
|
*
|
|
* This implicitly marks the task as in-progress.
|
|
* (This information is used to determine whether all tasks have been completed.)
|
|
*
|
|
* @return The next task available for processing or `null`, if no task can be processed at the
|
|
* moment (including if there are no more unprocessed tasks).
|
|
*/
|
|
getNextTask(): Task|null;
|
|
|
|
/**
|
|
* Mark a task as completed.
|
|
*
|
|
* This removes the task from the internal list of in-progress tasks.
|
|
* (This information is used to determine whether all tasks have been completed.)
|
|
*
|
|
* @param task The task to mark as completed.
|
|
*/
|
|
markTaskCompleted(task: Task): void;
|
|
|
|
/**
|
|
* Return a string representation of the task queue (for debugging purposes).
|
|
*
|
|
* @return A string representation of the task queue.
|
|
*/
|
|
toString(): string;
|
|
}
|