@eagleoutice/flowr 1.4.2 → 1.5.0

package/benchmark/slicer.js

@@ -1,213 +0,0 @@
-"use strict";
-/**
- * Provides a top-level slicer that can be used to slice code *and* retrieve stats.
- * @module
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BenchmarkSlicer = exports.benchmarkLogger = void 0;
-const r_bridge_1 = require("../r-bridge");
-const stopwatch_1 = require("./stopwatch");
-const assert_1 = require("../util/assert");
-const slicing_1 = require("../slicing");
-const fs_1 = __importDefault(require("fs"));
-const log_1 = require("../util/log");
-const core_1 = require("../core");
-const strings_1 = require("../util/strings");
-exports.benchmarkLogger = log_1.log.getSubLogger({ name: 'benchmark' });
-/**
- * A slicer that can be used to slice exactly one file (multiple times).
- * It holds its own {@link RShell} instance, maintains a cached dataflow and keeps measurements.
- *
- * Make sure to call {@link init} to initialize the slicer, before calling {@link slice}.
- * After slicing, call {@link finish} to close the R session and retrieve the stats.
- *
- * @note Under the hood, the benchmark slicer maintains a {@link SteppingSlicer}.
- */
-class BenchmarkSlicer {
-    /** Measures all data that is recorded *once* per slicer (complete setup up to the dataflow graph creation) */
-    commonMeasurements = new stopwatch_1.Measurements();
-    perSliceMeasurements = new Map();
-    shell;
-    stats;
-    loadedXml;
-    dataflow;
-    ai;
-    normalizedAst;
-    totalStopwatch;
-    finished = false;
-    // Yes this is dirty, but we know that we assign the stepper during the initialization and this saves us from having to check for nullability every time
-    stepper = null;
-    constructor() {
-        this.totalStopwatch = this.commonMeasurements.start('total');
-        this.shell = this.commonMeasurements.measure('initialize R session', () => new r_bridge_1.RShell());
-    }
-    /**
-     * Initialize the slicer on the given request.
-     * Can only be called once for each instance.
-     */
-    async init(request) {
-        (0, assert_1.guard)(this.stats === undefined, 'cannot initialize the slicer twice');
-        this.stepper = new core_1.SteppingSlicer({
-            shell: this.shell,
-            request: { ...request },
-            stepOfInterest: core_1.LAST_STEP,
-            criterion: []
-        });
-        this.loadedXml = await this.measureCommonStep('parse', 'retrieve AST from R code');
-        this.normalizedAst = await this.measureCommonStep('normalize', 'normalize R AST');
-        this.dataflow = await this.measureCommonStep('dataflow', 'produce dataflow information');
-        this.stepper.switchToSliceStage();
-        await this.calculateStatsAfterInit(request);
-    }
-    async calculateStatsAfterInit(request) {
-        const loadedContent = request.request === 'text' ? request.content : fs_1.default.readFileSync(request.content, 'utf-8');
-        // retrieve number of R tokens - flowr_parsed should still contain the last parsed code
-        const numberOfRTokens = await (0, r_bridge_1.retrieveNumberOfRTokensOfLastParse)(this.shell);
-        (0, assert_1.guard)(this.normalizedAst !== undefined, 'normalizedAst should be defined after initialization');
-        (0, assert_1.guard)(this.dataflow !== undefined, 'dataflow should be defined after initialization');
-        // collect dataflow graph size
-        const vertices = [...this.dataflow.graph.vertices(true)];
-        let numberOfEdges = 0;
-        let numberOfCalls = 0;
-        let numberOfDefinitions = 0;
-        for (const [n, info] of vertices) {
-            const outgoingEdges = this.dataflow.graph.outgoingEdges(n);
-            numberOfEdges += outgoingEdges?.size ?? 0;
-            if (info.tag === 'function-call') {
-                numberOfCalls++;
-            }
-            else if (info.tag === 'function-definition') {
-                numberOfDefinitions++;
-            }
-        }
-        this.stats = {
-            commonMeasurements: new Map(),
-            perSliceMeasurements: this.perSliceMeasurements,
-            request,
-            input: {
-                numberOfLines: loadedContent.split('\n').length,
-                numberOfCharacters: loadedContent.length,
-                numberOfNonWhitespaceCharacters: (0, strings_1.withoutWhitespace)(loadedContent).length,
-                numberOfRTokens: numberOfRTokens,
-                numberOfNormalizedTokens: [...(0, r_bridge_1.collectAllIds)(this.normalizedAst.ast)].length
-            },
-            dataflow: {
-                numberOfNodes: [...this.dataflow.graph.vertices(true)].length,
-                numberOfEdges: numberOfEdges,
-                numberOfCalls: numberOfCalls,
-                numberOfFunctionDefinitions: numberOfDefinitions
-            }
-        };
-    }
-    /**
-   * Slice for the given {@link SlicingCriteria}.
-   * @see SingleSlicingCriterion
-   *
-   * @returns The per slice stats retrieved for this slicing criteria
-   */
-    async slice(...slicingCriteria) {
-        exports.benchmarkLogger.trace(`try to slice for criteria ${JSON.stringify(slicingCriteria)}`);
-        this.guardActive();
-        (0, assert_1.guard)(!this.perSliceMeasurements.has(slicingCriteria), 'do not slice the same criteria combination twice');
-        const measurements = new stopwatch_1.Measurements();
-        const stats = {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            measurements: undefined,
-            slicingCriteria: [],
-            numberOfDataflowNodesSliced: 0,
-            timesHitThreshold: 0,
-            reconstructedCode: {
-                code: '',
-                autoSelected: 0
-            }
-        };
-        this.perSliceMeasurements.set(slicingCriteria, stats);
-        this.stepper.updateCriterion(slicingCriteria);
-        const totalStopwatch = measurements.start('total');
-        const slicedOutput = await this.measureSliceStep('slice', measurements, 'static slicing');
-        stats.slicingCriteria = slicedOutput.decodedCriteria;
-        stats.reconstructedCode = await this.measureSliceStep('reconstruct', measurements, 'reconstruct code');
-        totalStopwatch.stop();
-        exports.benchmarkLogger.debug(`Produced code for ${JSON.stringify(slicingCriteria)}: ${stats.reconstructedCode.code}`);
-        const results = this.stepper.getResults(false);
-        if (exports.benchmarkLogger.settings.minLevel >= 3 /* LogLevel.Info */) {
-            exports.benchmarkLogger.info(`mapped slicing criteria: ${slicedOutput.decodedCriteria.map(c => {
-                const node = results.normalize.idMap.get(c.id);
-                return `\n-   id: ${c.id}, location: ${JSON.stringify(node?.location)}, lexeme: ${JSON.stringify(node?.lexeme)}`;
-            }).join('')}`);
-        }
-        // if it is not in the dataflow graph it was kept to be safe and should not count to the included nodes
-        stats.numberOfDataflowNodesSliced = [...slicedOutput.result].filter(id => results.dataflow.graph.hasNode(id, false)).length;
-        stats.timesHitThreshold = slicedOutput.timesHitThreshold;
-        stats.measurements = measurements.get();
-        return {
-            stats,
-            slice: slicedOutput,
-            code: stats.reconstructedCode
-        };
-    }
-    /** Bridging the gap between the new internal and the old names for the benchmarking */
-    async measureCommonStep(expectedStep, keyToMeasure) {
-        const { result } = await this.commonMeasurements.measureAsync(keyToMeasure, () => this.stepper.nextStep(expectedStep));
-        return result;
-    }
-    async measureSliceStep(expectedStep, measure, keyToMeasure) {
-        const { result } = await measure.measureAsync(keyToMeasure, () => this.stepper.nextStep(expectedStep));
-        return result;
-    }
-    guardActive() {
-        (0, assert_1.guard)(this.stats !== undefined && !this.finished, 'need to call init before, and can not do after finish!');
-    }
-    /**
-   * Call {@link slice} for all slicing criteria that match the given filter.
-   * See {@link collectAllSlicingCriteria} for details.
-   * <p>
-   * the `report` function will be called *before* each individual slice is performed.
-   *
-   * @returns The number of slices that were produced
-   *
-   * @see collectAllSlicingCriteria
-   * @see SlicingCriteriaFilter
-   */
-    async sliceForAll(filter, report = () => { }) {
-        this.guardActive();
-        let count = 0;
-        const allCriteria = [...(0, slicing_1.collectAllSlicingCriteria)(this.normalizedAst.ast, filter)];
-        for (const slicingCriteria of allCriteria) {
-            report(count, allCriteria.length, allCriteria);
-            await this.slice(...slicingCriteria);
-            count++;
-        }
-        return count;
-    }
-    /**
-   * Retrieves the final stats and closes the shell session.
-   * Can be called multiple times to retrieve the stored stats, but will only close the session once (the first time).
-   */
-    finish() {
-        (0, assert_1.guard)(this.stats !== undefined, 'need to call init before finish');
-        if (!this.finished) {
-            this.commonMeasurements.measure('close R session', () => this.shell.close());
-            this.totalStopwatch.stop();
-            this.finished = true;
-        }
-        this.stats.commonMeasurements = this.commonMeasurements.get();
-        return {
-            stats: this.stats,
-            parse: this.loadedXml,
-            dataflow: this.dataflow,
-            normalize: this.normalizedAst
-        };
-    }
-    /**
-   * Only call in case of an error - if the session must be closed and the benchmark itself is to be considered failed/dead.
-   */
-    ensureSessionClosed() {
-        this.shell.close();
-    }
-}
-exports.BenchmarkSlicer = BenchmarkSlicer;
-//# sourceMappingURL=slicer.js.map

package/benchmark/stats/index.d.ts

@@ -1,10 +0,0 @@
-export * from './print';
-export * from './stats';
-export * from '../../util/summarizer/benchmark/summarizer';
-export { UltimateSlicerStats } from '../../util/summarizer/benchmark/data';
-export { SummarizedPerSliceStats } from '../../util/summarizer/benchmark/data';
-export { Reduction } from '../../util/summarizer/benchmark/data';
-export { SummarizedSlicerStats } from '../../util/summarizer/benchmark/data';
-export { summarizeSummarizedMeasurement } from '../../util/summarizer/benchmark/first-phase/process';
-export { summarizeMeasurement } from '../../util/summarizer/benchmark/first-phase/process';
-export { summarizeSlicerStats } from '../../util/summarizer/benchmark/first-phase/process';

package/benchmark/stats/index.js

@@ -1,27 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.summarizeSlicerStats = exports.summarizeMeasurement = exports.summarizeSummarizedMeasurement = void 0;
-__exportStar(require("./print"), exports);
-__exportStar(require("./stats"), exports);
-__exportStar(require("../../util/summarizer/benchmark/summarizer"), exports);
-var process_1 = require("../../util/summarizer/benchmark/first-phase/process");
-Object.defineProperty(exports, "summarizeSummarizedMeasurement", { enumerable: true, get: function () { return process_1.summarizeSummarizedMeasurement; } });
-var process_2 = require("../../util/summarizer/benchmark/first-phase/process");
-Object.defineProperty(exports, "summarizeMeasurement", { enumerable: true, get: function () { return process_2.summarizeMeasurement; } });
-var process_3 = require("../../util/summarizer/benchmark/first-phase/process");
-Object.defineProperty(exports, "summarizeSlicerStats", { enumerable: true, get: function () { return process_3.summarizeSlicerStats; } });
-//# sourceMappingURL=index.js.map

package/benchmark/stats/print.d.ts

@@ -1,7 +0,0 @@
-import type { SummarizedSlicerStats, UltimateSlicerStats } from '../../util/summarizer/benchmark/data';
-/**
- * Converts the given stats to a human-readable string.
- * You may have to {@link summarizeSlicerStats | summarize} the stats first.
- */
-export declare function stats2string(stats: SummarizedSlicerStats): string;
-export declare function ultimateStats2String(stats: UltimateSlicerStats): string;

package/benchmark/stats/print.js

@@ -1,155 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ultimateStats2String = exports.stats2string = void 0;
-/**
- * This module is tasked with processing the results of the benchmarking (see {@link SummarizedSlicerStats}).
- * @module
- */
-const assert_1 = require("../../util/assert");
-const padSize = 15;
-function pad(string) {
-    return String(string).padStart(padSize, ' ');
-}
-function divWithRest(dividend, divisor) {
-    return [dividend / divisor, dividend % divisor];
-}
-function formatNanoseconds(nanoseconds) {
-    if (nanoseconds < 0) {
-        return '??';
-    }
-    const [seconds, rest] = divWithRest(typeof nanoseconds === 'number' ? BigInt(Math.round(nanoseconds)) : nanoseconds, BigInt(1e9));
-    const [milliseconds, remainingNanoseconds] = divWithRest(rest, BigInt(1e6));
-    const secondsStr = seconds > 0 ? `${String(seconds).padStart(2, '0')}.` : '';
-    const millisecondsStr = seconds > 0 ? `${String(milliseconds).padStart(3, '0')}:` : `${String(milliseconds)}:`;
-    const nanoStr = String(remainingNanoseconds).padEnd(3, '0').substring(0, 3);
-    const unit = seconds === 0n ? 'ms' : ' s'; /* space for padding */
-    return pad(`${secondsStr}${millisecondsStr}${nanoStr}${unit}`);
-}
-function print(measurements, key) {
-    const time = measurements.get(key);
-    (0, assert_1.guard)(time !== undefined, `Measurement for ${JSON.stringify(key)} not found`);
-    return formatNanoseconds(time);
-}
-function formatSummarizedTimeMeasure(measure) {
-    if (measure === undefined) {
-        return '??';
-    }
-    return `${formatNanoseconds(measure.min)} - ${formatNanoseconds(measure.max)} (median: ${formatNanoseconds(measure.median)}, mean: ${formatNanoseconds(measure.mean)}, std: ${formatNanoseconds(measure.std)})`;
-}
-function roundTo(num, digits = 4) {
-    const factor = Math.pow(10, digits);
-    return Math.round(num * factor) / factor;
-}
-function asPercentage(num) {
-    if (isNaN(num)) {
-        return '??%';
-    }
-    return pad(`${roundTo(num * 100, 3)}%`);
-}
-function asFloat(num) {
-    return pad(roundTo(num));
-}
-function formatSummarizedMeasure(measure, fmt = asFloat) {
-    if (measure === undefined) {
-        return '??';
-    }
-    return `${fmt(measure.min)} - ${fmt(measure.max)} (median: ${fmt(measure.median)}, mean: ${fmt(measure.mean)}, std: ${fmt(measure.std)})`;
-}
-function printSummarizedMeasurements(stats, key) {
-    const measure = stats.measurements.get(key);
-    (0, assert_1.guard)(measure !== undefined, `Measurement for ${JSON.stringify(key)} not found`);
-    return formatSummarizedTimeMeasure(measure);
-}
-function printCountSummarizedMeasurements(stats) {
-    const range = `${stats.min} - ${stats.max}`.padStart(padSize, ' ');
-    return `${range} (median: ${stats.median}, mean: ${stats.mean}, std: ${stats.std})`;
-}
-/**
- * Converts the given stats to a human-readable string.
- * You may have to {@link summarizeSlicerStats | summarize} the stats first.
- */
-function stats2string(stats) {
-    let result = `
-Request: ${JSON.stringify(stats.request)}
-Shell init time:              ${print(stats.commonMeasurements, 'initialize R session')}
-AST retrieval:                ${print(stats.commonMeasurements, 'retrieve AST from R code')}
-AST normalization:            ${print(stats.commonMeasurements, 'normalize R AST')}
-Dataflow creation:            ${print(stats.commonMeasurements, 'produce dataflow information')}
-
-Slicing summary for ${stats.perSliceMeasurements.numberOfSlices} slice${stats.perSliceMeasurements.numberOfSlices !== 1 ? 's' : ''}:`;
-    if (stats.perSliceMeasurements.numberOfSlices > 0) {
-        result += `
-  Total:                      ${printSummarizedMeasurements(stats.perSliceMeasurements, 'total')}
-  Slice creation:             ${printSummarizedMeasurements(stats.perSliceMeasurements, 'static slicing')}
-  Reconstruction:             ${printSummarizedMeasurements(stats.perSliceMeasurements, 'reconstruct code')}
-  Used Slice Criteria Sizes:  ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceCriteriaSizes)}
-  Result Slice Sizes:   
-    Number of lines:                     ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.lines)}
-    Number of characters:                ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.characters)}
-    Number of non whitespace characters: ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.nonWhitespaceCharacters)}
-    Number of auto selected:             ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.autoSelected)}
-    Number of R tokens:                  ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.tokens)}
-    Normalized R tokens:                 ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.normalizedTokens)}
-    Number of dataflow nodes:            ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.dataflowNodes)}
-`;
-    }
-    return `${result}
-Shell close:                  ${print(stats.commonMeasurements, 'close R session')}
-Total:                        ${print(stats.commonMeasurements, 'total')}
-
-Input:
-  Number of lines:                     ${pad(stats.input.numberOfLines)}
-  Number of characters:                ${pad(stats.input.numberOfCharacters)}
-  Number of non whitespace characters: ${pad(stats.input.numberOfNonWhitespaceCharacters)}
-  Number of tokens:                    ${pad(stats.input.numberOfRTokens)}
-  Normalized R tokens:                 ${pad(stats.input.numberOfNormalizedTokens)}
-
-Dataflow:
-  Number of nodes:            ${pad(stats.dataflow.numberOfNodes)}
-  Number of edges:            ${pad(stats.dataflow.numberOfEdges)}
-  Number of calls:            ${pad(stats.dataflow.numberOfCalls)}
-  Number of function defs:    ${pad(stats.dataflow.numberOfFunctionDefinitions)}`;
-}
-exports.stats2string = stats2string;
-function ultimateStats2String(stats) {
-    // Used Slice Criteria Sizes:  ${formatSummarizedMeasure(stats.perSliceMeasurements.sliceCriteriaSizes)}
-    return `
-Summarized: ${stats.totalRequests} requests and ${stats.totalSlices} slices
-Shell init time:              ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('initialize R session'))}
-AST retrieval:                ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('retrieve AST from R code'))}
-AST normalization:            ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('normalize R AST'))}
-Dataflow creation:            ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('produce dataflow information'))}
-
-Slice summary for:
-  Total:                      ${formatSummarizedTimeMeasure(stats.perSliceMeasurements.get('total'))}
-  Slice creation:             ${formatSummarizedTimeMeasure(stats.perSliceMeasurements.get('static slicing'))}
-  Reconstruction:             ${formatSummarizedTimeMeasure(stats.perSliceMeasurements.get('reconstruct code'))}
-  Failed to Re-Parse:         ${pad(stats.failedToRepParse)}/${stats.totalSlices}
-  Times hit Threshold:        ${pad(stats.timesHitThreshold)}/${stats.totalSlices} 
-  Reductions (reduced by x%):   
-    Number of lines:                     ${formatSummarizedMeasure(stats.reduction.numberOfLines, asPercentage)}
-    Number of lines no auto:             ${formatSummarizedMeasure(stats.reduction.numberOfLinesNoAutoSelection, asPercentage)}
-    Number of characters:                ${formatSummarizedMeasure(stats.reduction.numberOfCharacters, asPercentage)}
-    Number of non whitespace characters: ${formatSummarizedMeasure(stats.reduction.numberOfNonWhitespaceCharacters, asPercentage)}
-    Number of R tokens:                  ${formatSummarizedMeasure(stats.reduction.numberOfRTokens, asPercentage)}
-    Normalized R tokens:                 ${formatSummarizedMeasure(stats.reduction.numberOfNormalizedTokens, asPercentage)}
-    Number of dataflow nodes:            ${formatSummarizedMeasure(stats.reduction.numberOfDataflowNodes, asPercentage)}
-
-Shell close:                  ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('close R session'))}
-Total:                        ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('total'))}
-
-Input:
-  Number of lines:                     ${formatSummarizedMeasure(stats.input.numberOfLines)}
-  Number of characters:                ${formatSummarizedMeasure(stats.input.numberOfCharacters)}
-  Number of non whitespace characters: ${formatSummarizedMeasure(stats.input.numberOfNonWhitespaceCharacters)}
-  Number of tokens:                    ${formatSummarizedMeasure(stats.input.numberOfRTokens)}
-  Normalized R tokens:                 ${formatSummarizedMeasure(stats.input.numberOfNormalizedTokens)}
-
-Dataflow:
-  Number of nodes:            ${formatSummarizedMeasure(stats.dataflow.numberOfNodes)}
-  Number of edges:            ${formatSummarizedMeasure(stats.dataflow.numberOfEdges)}
-  Number of calls:            ${formatSummarizedMeasure(stats.dataflow.numberOfCalls)}
-  Number of function defs:    ${formatSummarizedMeasure(stats.dataflow.numberOfFunctionDefinitions)}`;
-}
-exports.ultimateStats2String = ultimateStats2String;
-//# sourceMappingURL=print.js.map

package/benchmark/stats/stats.d.ts

@@ -1,40 +0,0 @@
-import type { ReconstructionResult, SingleSlicingCriterion, SlicingCriteria } from '../../slicing';
-import type { NodeId, RParseRequestFromFile, RParseRequestFromText } from '../../r-bridge';
-export declare const CommonSlicerMeasurements: readonly ["initialize R session", "retrieve AST from R code", "normalize R AST", "produce dataflow information", "close R session", "total"];
-export type CommonSlicerMeasurements = typeof CommonSlicerMeasurements[number];
-export declare const PerSliceMeasurements: readonly ["static slicing", "reconstruct code", "total"];
-export type PerSliceMeasurements = typeof PerSliceMeasurements[number];
-export type ElapsedTime = bigint;
-export interface PerSliceStats {
-    measurements: Map<PerSliceMeasurements, ElapsedTime>;
-    slicingCriteria: {
-        criterion: SingleSlicingCriterion;
-        id: NodeId;
-    }[];
-    reconstructedCode: ReconstructionResult;
-    numberOfDataflowNodesSliced: number;
-    timesHitThreshold: number;
-}
-export interface SlicerStatsInput<T = number> {
-    numberOfLines: T;
-    numberOfCharacters: T;
-    numberOfNonWhitespaceCharacters: T;
-    numberOfRTokens: T;
-    numberOfNormalizedTokens: T;
-}
-export interface SlicerStatsDataflow<T = number> {
-    numberOfNodes: T;
-    numberOfEdges: T;
-    numberOfCalls: T;
-    numberOfFunctionDefinitions: T;
-}
-/**
- * The statistics that are collected by the {@link BenchmarkSlicer} and used for benchmarking.
- */
-export interface SlicerStats {
-    commonMeasurements: Map<CommonSlicerMeasurements, ElapsedTime>;
-    perSliceMeasurements: Map<SlicingCriteria, PerSliceStats>;
-    request: RParseRequestFromFile | RParseRequestFromText;
-    input: SlicerStatsInput;
-    dataflow: SlicerStatsDataflow;
-}

package/benchmark/stats/stats.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PerSliceMeasurements = exports.CommonSlicerMeasurements = void 0;
-exports.CommonSlicerMeasurements = ['initialize R session', 'retrieve AST from R code', 'normalize R AST', 'produce dataflow information', 'close R session', 'total'];
-exports.PerSliceMeasurements = ['static slicing', 'reconstruct code', 'total'];
-//# sourceMappingURL=stats.js.map

package/benchmark/stopwatch.d.ts

@@ -1,35 +0,0 @@
-export interface IStoppableStopwatch {
-    /** Stop the given stopwatch. */
-    stop(): void;
-}
-/**
- * Allows to measure keys of type `T` with a `Stopwatch`.
- *
- * Measure with {@link start}, {@link measure} or {@link measureAsync}, retrieve the final measurements with {@link get}.
- */
-export declare class Measurements<T> {
-    private measurements;
-    /**
-   * Start a timer for the given key, and guards that this is the first time this key is started.
-   * Call {@link IStoppableStopwatch#stop} on the returned stopwatch to stop the timer.
-   */
-    start(key: T): IStoppableStopwatch;
-    /**
-   * Automatically call {@link Measurements#start | start} and the corresponding stop to measure the execution time of the given function.
-   * @see {@link measureAsync}
-   */
-    measure<Out>(key: T, fn: () => Out): Out;
-    /**
-   * Similar to {@link measure}, but await the promise as part of the measurement
-   *
-     * @param key - The key to write the resulting measurement to
-     * @param fn  - The function to measure
-     *
-   * @see measure
-   */
-    measureAsync<Out>(key: T, fn: () => Promise<Out>): Promise<Out>;
-    /**
-   * Retrieve all measure-results, requires that all stop-watches that have been started have also been stopped.
-   */
-    get(): Map<T, bigint>;
-}

package/benchmark/stopwatch.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Measurements = void 0;
-const assert_1 = require("../util/assert");
-/** unguarded start-stop wrapper */
-class Stopwatch {
-    timeStart;
-    timeEnd;
-    stopped = false;
-    start() {
-        this.timeStart = process.hrtime.bigint();
-    }
-    stop() {
-        this.timeEnd = process.hrtime.bigint();
-        // check after to not affect measurements
-        (0, assert_1.guard)(!this.stopped, 'cannot stop a stopwatch twice');
-        this.stopped = true;
-    }
-    get() {
-        (0, assert_1.guard)(this.timeStart !== undefined && this.timeEnd !== undefined, 'cannot get elapsed time as the stopwatch has not been started/stopped');
-        return this.timeEnd - this.timeStart;
-    }
-}
-/**
- * Allows to measure keys of type `T` with a `Stopwatch`.
- *
- * Measure with {@link start}, {@link measure} or {@link measureAsync}, retrieve the final measurements with {@link get}.
- */
-class Measurements {
-    measurements = new Map();
-    /**
-   * Start a timer for the given key, and guards that this is the first time this key is started.
-   * Call {@link IStoppableStopwatch#stop} on the returned stopwatch to stop the timer.
-   */
-    start(key) {
-        // we guard *before* starting so there is no additional time penalty
-        (0, assert_1.guard)(!this.measurements.has(key), `already started stop watch for ${JSON.stringify(key)}`);
-        const stopwatch = new Stopwatch();
-        this.measurements.set(key, stopwatch);
-        stopwatch.start();
-        return stopwatch;
-    }
-    /**
-   * Automatically call {@link Measurements#start | start} and the corresponding stop to measure the execution time of the given function.
-   * @see {@link measureAsync}
-   */
-    measure(key, fn) {
-        const stopwatch = this.start(key);
-        const result = fn();
-        stopwatch.stop();
-        return result;
-    }
-    /**
-   * Similar to {@link measure}, but await the promise as part of the measurement
-   *
-     * @param key - The key to write the resulting measurement to
-     * @param fn  - The function to measure
-     *
-   * @see measure
-   */
-    async measureAsync(key, fn) {
-        const stopwatch = this.start(key);
-        const result = await fn();
-        stopwatch.stop();
-        return result;
-    }
-    /**
-   * Retrieve all measure-results, requires that all stop-watches that have been started have also been stopped.
-   */
-    get() {
-        const result = new Map();
-        for (const [key, stopwatch] of this.measurements) {
-            result.set(key, stopwatch.get());
-        }
-        return result;
-    }
-}
-exports.Measurements = Measurements;
-//# sourceMappingURL=stopwatch.js.map

package/cli/benchmark-app.d.ts

@@ -1,10 +0,0 @@
-export interface BenchmarkCliOptions {
-    verbose: boolean;
-    help: boolean;
-    input: string[];
-    output: string;
-    slice: string;
-    parallel: number;
-    limit?: number;
-    runs?: number;
-}

package/cli/benchmark-app.js

@@ -1,67 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const log_1 = require("../util/log");
-const files_1 = require("../util/files");
-const parallel_1 = require("../util/parallel");
-const assert_1 = require("../util/assert");
-const fs_1 = __importDefault(require("fs"));
-const common_1 = require("./common");
-const path_1 = __importDefault(require("path"));
-const options = (0, common_1.processCommandLineArgs)('benchmark', [], {
-    subtitle: 'Slice given files with additional benchmark information',
-    examples: [
-        '{italic example-folder/}',
-        '{bold --help}'
-    ]
-});
-if (options.input.length === 0) {
-    console.error('No input files given. Nothing to do. See \'--help\' if this is an error.');
-    process.exit(0);
-}
-(0, assert_1.guard)(options.slice === 'all' || options.slice === 'no', 'slice must be either all or no');
-(0, assert_1.guard)(options.runs === undefined || options.runs > 0, 'runs must be greater than zero');
-function removeIfExists(summarizedRaw) {
-    if (fs_1.default.existsSync(summarizedRaw)) {
-        console.log(`Removing existing ${summarizedRaw}`);
-        fs_1.default.rmSync(summarizedRaw, { recursive: true });
-    }
-}
-async function benchmark() {
-    removeIfExists(options.output);
-    fs_1.default.mkdirSync(options.output);
-    console.log(`Storing output in ${options.output}`);
-    console.log(`Using ${options.parallel} parallel executors`);
-    // we do not use the limit argument to be able to pick the limit randomly
-    const files = [];
-    for await (const file of (0, files_1.allRFilesFrom)(options.input)) {
-        files.push(file);
-    }
-    if (options.limit) {
-        log_1.log.info(`limiting to ${options.limit} files`);
-        // shuffle and limit
-        files.sort(() => Math.random() - 0.5);
-    }
-    const limit = options.limit ?? files.length;
-    const verboseAdd = options.verbose ? ['--verbose'] : [];
-    const args = files.map((f, i) => [
-        '--input', f.content,
-        '--file-id', `${i}`,
-        '--output', path_1.default.join(options.output, `${path_1.default.parse(f.content).name}.json`),
-        '--slice', options.slice, ...verboseAdd
-    ]);
-    const runs = options.runs ?? 1;
-    for (let i = 1; i <= runs; i++) {
-        console.log(`Run ${i} of ${runs}`);
-        const pool = new parallel_1.LimitedThreadPool(`${__dirname}/benchmark-helper-app`, 
-        // 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);
-        await pool.run();
-        const stats = pool.getStats();
-        console.log(`Run ${i} of ${runs}: Benchmarked ${stats.counter} files, skipped ${stats.skipped.length} files due to errors`);
-    }
-}
-void benchmark();
-//# sourceMappingURL=benchmark-app.js.map