Added 'per-file-time-limit' cli option (#1414)

feat(benchmark): add 'per-file-time-limit' cli option

Author: Slartibartfass2

src/cli/benchmark-app.ts

@@ -21,6 +21,7 @@ export interface BenchmarkCliOptions {
 	'enable-pointer-tracking': boolean
 	'max-file-slices':         number
 	threshold?:                number
+	'per-file-time-limit'?:    number
 }
 
 const options = processCommandLineArgs<BenchmarkCliOptions>('benchmark', [],{
@@ -107,7 +108,8 @@ async function benchmark() {
 			// we reverse here "for looks", since the helper pops from the end, and we want file ids to be ascending :D
 			args.map(a => [...a, '--run-num', `${i}`]).reverse(),
 			limit,
-			options.parallel
+			options.parallel,
+			options['per-file-time-limit']
 		);
 		await pool.run();
 		const stats = pool.getStats();

src/cli/common/options.ts

@@ -34,6 +34,7 @@ export const benchmarkOptions: OptionDefinition[] = [
 	{ name: 'enable-pointer-tracking',  type: Boolean, description: 'Run dataflow analysis with pointer tracking', defaultValue: false },
 	{ name: 'max-file-slices',          type: Number,  description: 'If file has more than passed number of slices, the file is not processed', defaultValue: -1, typeLabel: '{underline number}' },
 	{ name: 'threshold',    alias: 't', type: Number,  description: 'How many re-visits of the same node are ok?', defaultValue: undefined, typeLabel: '{underline number}' },
+	{ name: 'per-file-time-limit',      type: Number,  description: 'Time limit in milliseconds to process single file (disabled by default)', defaultValue: undefined, typeLabel: '{underline number}' },
 ];
 
 export const benchmarkHelperOptions: OptionDefinition[] = [

src/dataflow/environments/overwrite.ts

@@ -3,6 +3,7 @@ import type { REnvironmentInformation, IEnvironment } from './environment';
 import { BuiltInEnvironment , Environment } from './environment';
 import type { IdentifierDefinition } from './identifier';
 import type { ControlDependency } from '../info';
+import { log } from '../../util/log';
 
 function anyIsMaybeOrEmpty(values: readonly IdentifierDefinition[]): boolean {
 	if(values.length === 0) {
@@ -20,6 +21,9 @@ export function overwriteIEnvironmentWith(base: IEnvironment | undefined, next:
 	guard(base !== undefined && next !== undefined, 'can not overwrite environments with undefined');
 	const map = new Map(base.memory);
 	for(const [key, values] of next.memory) {
+		if(values.length > 1_000_000) {
+			log.warn(`Overwriting environment with ${values.length} definitions for ${key}`);
+		}
 		const hasMaybe = applyCds?.length === 0 || applyCds !== undefined ? true : anyIsMaybeOrEmpty(values);
 		if(hasMaybe) {
 			const old = map.get(key);

src/util/parallel.ts

@@ -16,25 +16,27 @@ type WorkingQueue = Arguments[]
  * It offers a work stealing thread pool executor.
  */
 export class LimitedThreadPool {
-	private readonly workingQueue: WorkingQueue;
-	private readonly limit:        number;
-	private readonly parallel:     number;
-	private readonly module:       string;
+	private readonly workingQueue:  WorkingQueue;
+	private readonly limit:         number;
+	private readonly parallel:      number;
+	private readonly module:        string;
 	private counter = 0;
-	private skipped:               Arguments[] = [];
+	private skipped:                Arguments[] = [];
 	private currentlyRunning = new Set<Arguments>();
-	private reportingInterval:     NodeJS.Timer | undefined = undefined;
+	private reportingInterval:      NodeJS.Timer | undefined = undefined;
+	private readonly timeLimitInMs: number | undefined;
 
 	/**
    * Create a new parallel helper that runs the given `module` once for each list of {@link Arguments} in the `queue`.
    * The `limit` stops the execution if `<limit>` number of runs exited successfully.
    * The `parallel` parameter limits the number of parallel executions.
    */
-	constructor(module: string, queue: WorkingQueue, limit: number, parallel: number) {
+	constructor(module: string, queue: WorkingQueue, limit: number, parallel: number, timeLimitInMs?: number) {
 		this.workingQueue = queue;
 		this.limit = limit;
 		this.module = module;
 		this.parallel = parallel;
+		this.timeLimitInMs = timeLimitInMs;
 	}
 
 	public async run(): Promise<void> {
@@ -69,9 +71,16 @@ export class LimitedThreadPool {
 
 		const child = cp.fork(this.module, args);
 		child.on('exit', this.onChildExit(args));
+		let timeout: NodeJS.Timeout | undefined;
+		if(this.timeLimitInMs) {
+			timeout = setTimeout(() => {
+				log.error(`Killing child process with '${JSON.stringify(args)}' after ${this.timeLimitInMs}ms`);
+				child.kill();
+			}, this.timeLimitInMs);
+		}
 
 		// schedule re-schedule
-		await new Promise<void>(resolve => child.on('exit', resolve)).then(() => this.runNext());
+		await new Promise<void>(resolve => child.on('exit', resolve)).then(() => clearTimeout(timeout)).then(() => this.runNext());
 	}