@eagleoutice/flowr 1.4.2 → 1.5.1

package/util/summarizer/benchmark/first-phase/process.js

@@ -1,217 +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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.summarizeReductions = exports.summarizeSummarizedMeasurement = exports.summarizeMeasurement = exports.summarizeSlicerStats = void 0;
-const tmp = __importStar(require("tmp"));
-const assert_1 = require("../../../assert");
-const log_1 = require("../../../log");
-const defaultmap_1 = require("../../../defaultmap");
-const r_bridge_1 = require("../../../../r-bridge");
-const strings_1 = require("../../../strings");
-const fs_1 = __importDefault(require("fs"));
-const arrays_1 = require("../../../arrays");
-const tempfile = (() => {
-    let _tempfile = undefined;
-    return () => {
-        if (_tempfile === undefined) {
-            _tempfile = tmp.fileSync({ postfix: '.R', keep: false });
-            process.on('beforeExit', () => _tempfile?.removeCallback());
-        }
-        return _tempfile;
-    };
-})();
-function safeDivPercentage(a, b) {
-    if (isNaN(a) || isNaN(b)) {
-        return undefined;
-    }
-    else if (b === 0) {
-        return a === 0 ? 0 : undefined;
-    }
-    else {
-        const result = 1 - (a / b);
-        if (isNaN(result)) {
-            log_1.log.error(`NaN for ${a} and ${b}\n`);
-            return undefined;
-        }
-        else {
-            return result;
-        }
-    }
-}
-function calculateReductionForSlice(input, dataflow, perSlice) {
-    return {
-        numberOfLines: safeDivPercentage(perSlice.lines, input.numberOfLines),
-        numberOfLinesNoAutoSelection: safeDivPercentage(perSlice.lines - perSlice.autoSelected, input.numberOfLines),
-        numberOfCharacters: safeDivPercentage(perSlice.characters, input.numberOfCharacters),
-        numberOfNonWhitespaceCharacters: safeDivPercentage(perSlice.nonWhitespaceCharacters, input.numberOfNonWhitespaceCharacters),
-        numberOfRTokens: safeDivPercentage(perSlice.tokens, input.numberOfRTokens),
-        numberOfNormalizedTokens: safeDivPercentage(perSlice.normalizedTokens, input.numberOfNormalizedTokens),
-        numberOfDataflowNodes: safeDivPercentage(perSlice.dataflowNodes, dataflow.numberOfNodes)
-    };
-}
-/**
- * Summarizes the given stats by calculating the min, max, median, mean, and the standard deviation for each measurement.
- * @see Slicer
- */
-async function summarizeSlicerStats(stats, report = () => {
-}) {
-    const perSliceStats = stats.perSliceMeasurements;
-    const collect = new defaultmap_1.DefaultMap(() => []);
-    const sizeOfSliceCriteria = [];
-    const reParseShellSession = new r_bridge_1.RShell();
-    const reductions = [];
-    let failedOutputs = 0;
-    const sliceSize = {
-        lines: [],
-        autoSelected: [],
-        characters: [],
-        nonWhitespaceCharacters: [],
-        tokens: [],
-        normalizedTokens: [],
-        dataflowNodes: []
-    };
-    let timesHitThreshold = 0;
-    for (const [criteria, perSliceStat] of perSliceStats) {
-        report(criteria, perSliceStat);
-        for (const measure of perSliceStat.measurements) {
-            collect.get(measure[0]).push(Number(measure[1]));
-        }
-        sizeOfSliceCriteria.push(perSliceStat.slicingCriteria.length);
-        timesHitThreshold += perSliceStat.timesHitThreshold > 0 ? 1 : 0;
-        const { code: output, autoSelected } = perSliceStat.reconstructedCode;
-        sliceSize.autoSelected.push(autoSelected);
-        const lines = output.split('\n').length;
-        sliceSize.lines.push(lines);
-        sliceSize.characters.push(output.length);
-        const nonWhitespace = (0, strings_1.withoutWhitespace)(output).length;
-        sliceSize.nonWhitespaceCharacters.push(nonWhitespace);
-        // reparse the output to get the number of tokens
-        try {
-            // there seem to be encoding issues, therefore, we dump to a temp file
-            fs_1.default.writeFileSync(tempfile().name, output);
-            const reParsed = await (0, r_bridge_1.retrieveNormalizedAstFromRCode)({ request: 'file', content: tempfile().name }, reParseShellSession);
-            let numberOfNormalizedTokens = 0;
-            (0, r_bridge_1.visitAst)(reParsed.ast, _ => {
-                numberOfNormalizedTokens++;
-                return false;
-            });
-            sliceSize.normalizedTokens.push(numberOfNormalizedTokens);
-            const numberOfRTokens = await (0, r_bridge_1.retrieveNumberOfRTokensOfLastParse)(reParseShellSession);
-            sliceSize.tokens.push(numberOfRTokens);
-            reductions.push(calculateReductionForSlice(stats.input, stats.dataflow, {
-                lines: lines,
-                characters: output.length,
-                nonWhitespaceCharacters: nonWhitespace,
-                autoSelected: autoSelected,
-                tokens: numberOfRTokens,
-                normalizedTokens: numberOfNormalizedTokens,
-                dataflowNodes: perSliceStat.numberOfDataflowNodesSliced
-            }));
-        }
-        catch (e) {
-            console.error(`    ! Failed to re-parse the output of the slicer for ${JSON.stringify(criteria)}`); //, e
-            console.error(`      Code: ${output}\n`);
-            failedOutputs++;
-        }
-        sliceSize.dataflowNodes.push(perSliceStat.numberOfDataflowNodesSliced);
-    }
-    // summarize all measurements:
-    const summarized = new Map();
-    for (const [criterion, measurements] of collect.entries()) {
-        summarized.set(criterion, summarizeMeasurement(measurements));
-    }
-    reParseShellSession.close();
-    return {
-        ...stats,
-        perSliceMeasurements: {
-            numberOfSlices: perSliceStats.size,
-            sliceCriteriaSizes: summarizeMeasurement(sizeOfSliceCriteria),
-            measurements: summarized,
-            failedToRepParse: failedOutputs,
-            timesHitThreshold,
-            reduction: {
-                numberOfLines: summarizeMeasurement(reductions.map(r => r.numberOfLines).filter(assert_1.isNotUndefined)),
-                numberOfLinesNoAutoSelection: summarizeMeasurement(reductions.map(r => r.numberOfLinesNoAutoSelection).filter(assert_1.isNotUndefined)),
-                numberOfCharacters: summarizeMeasurement(reductions.map(r => r.numberOfCharacters).filter(assert_1.isNotUndefined)),
-                numberOfNonWhitespaceCharacters: summarizeMeasurement(reductions.map(r => r.numberOfNonWhitespaceCharacters).filter(assert_1.isNotUndefined)),
-                numberOfRTokens: summarizeMeasurement(reductions.map(r => r.numberOfRTokens).filter(assert_1.isNotUndefined)),
-                numberOfNormalizedTokens: summarizeMeasurement(reductions.map(r => r.numberOfNormalizedTokens).filter(assert_1.isNotUndefined)),
-                numberOfDataflowNodes: summarizeMeasurement(reductions.map(r => r.numberOfDataflowNodes).filter(assert_1.isNotUndefined))
-            },
-            sliceSize: {
-                lines: summarizeMeasurement(sliceSize.lines),
-                characters: summarizeMeasurement(sliceSize.characters),
-                nonWhitespaceCharacters: summarizeMeasurement(sliceSize.nonWhitespaceCharacters),
-                autoSelected: summarizeMeasurement(sliceSize.autoSelected),
-                tokens: summarizeMeasurement(sliceSize.tokens),
-                normalizedTokens: summarizeMeasurement(sliceSize.normalizedTokens),
-                dataflowNodes: summarizeMeasurement(sliceSize.dataflowNodes)
-            }
-        }
-    };
-}
-exports.summarizeSlicerStats = summarizeSlicerStats;
-function summarizeMeasurement(data, totalNumberOfDataPoints) {
-    // just to avoid in-place modification
-    const sorted = [...data].sort((a, b) => a - b);
-    const min = sorted[0];
-    const max = sorted[sorted.length - 1];
-    const median = sorted[Math.floor(sorted.length / 2)];
-    const total = (0, arrays_1.sum)(sorted);
-    const length = totalNumberOfDataPoints ?? sorted.length;
-    const mean = total / length;
-    // sqrt(sum(x-mean)^2 / n)
-    const std = Math.sqrt(sorted.map(x => (x - mean) ** 2).reduce((a, b) => a + b, 0) / length);
-    return { min, max, median, mean, std, total };
-}
-exports.summarizeMeasurement = summarizeMeasurement;
-function summarizeSummarizedMeasurement(data) {
-    const min = data.map(d => d.min).filter(assert_1.isNotUndefined).reduce((a, b) => Math.min(a, b), Infinity);
-    const max = data.map(d => d.max).filter(assert_1.isNotUndefined).reduce((a, b) => Math.max(a, b), -Infinity);
-    // get most average
-    const median = data.map(d => d.median).filter(assert_1.isNotUndefined).reduce((a, b) => a + b, 0) / data.length;
-    const mean = data.map(d => d.mean).filter(assert_1.isNotUndefined).reduce((a, b) => a + b, 0) / data.length;
-    // Method 1 of https://www.statology.org/averaging-standard-deviations/
-    const std = Math.sqrt(data.map(d => d.std ** 2).filter(assert_1.isNotUndefined).reduce((a, b) => a + b, 0) / data.length);
-    const total = data.map(d => d.total).filter(assert_1.isNotUndefined).reduce((a, b) => a + b, 0);
-    return { min, max, median, mean, std, total };
-}
-exports.summarizeSummarizedMeasurement = summarizeSummarizedMeasurement;
-function summarizeReductions(reductions) {
-    return {
-        numberOfDataflowNodes: summarizeSummarizedMeasurement(reductions.map(r => r.numberOfDataflowNodes)),
-        numberOfLines: summarizeSummarizedMeasurement(reductions.map(r => r.numberOfLines)),
-        numberOfCharacters: summarizeSummarizedMeasurement(reductions.map(r => r.numberOfCharacters)),
-        numberOfNonWhitespaceCharacters: summarizeSummarizedMeasurement(reductions.map(r => r.numberOfNonWhitespaceCharacters)),
-        numberOfLinesNoAutoSelection: summarizeSummarizedMeasurement(reductions.map(r => r.numberOfLinesNoAutoSelection)),
-        numberOfNormalizedTokens: summarizeSummarizedMeasurement(reductions.map(r => r.numberOfNormalizedTokens)),
-        numberOfRTokens: summarizeSummarizedMeasurement(reductions.map(r => r.numberOfRTokens))
-    };
-}
-exports.summarizeReductions = summarizeReductions;
-//# sourceMappingURL=process.js.map

package/util/summarizer/benchmark/second-phase/graph.d.ts

@@ -1,2 +0,0 @@
-import type { UltimateSlicerStats } from '../data';
-export declare function writeGraphOutput(ultimate: UltimateSlicerStats, outputGraphPath: string): void;

package/util/summarizer/benchmark/second-phase/graph.js

@@ -1,54 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeGraphOutput = void 0;
-const fs_1 = __importDefault(require("fs"));
-const json_1 = require("../../../json");
-function writeGraphOutput(ultimate, outputGraphPath) {
-    console.log(`Producing benchmark graph data (${outputGraphPath})...`);
-    const data = [];
-    for (const { name, measurements } of [{ name: 'per-file', measurements: ultimate.commonMeasurements }, { name: 'per-slice', measurements: ultimate.perSliceMeasurements }]) {
-        for (const [point, measurement] of measurements) {
-            if (point === 'close R session' || point === 'initialize R session') {
-                continue;
-            }
-            const pointName = point === 'total' ? `total ${name}` : point;
-            data.push({
-                name: pointName[0].toUpperCase() + pointName.slice(1),
-                unit: 'ms',
-                value: Number(measurement.mean / 1e6),
-                range: Number(measurement.std / 1e6),
-                extra: `median: ${(measurement.median / 1e6).toFixed(2)}ms`
-            });
-        }
-    }
-    data.push({
-        name: 'failed to reconstruct/re-parse',
-        unit: '#',
-        value: ultimate.failedToRepParse,
-        extra: `out of ${ultimate.totalSlices} slices`
-    });
-    data.push({
-        name: 'times hit threshold',
-        unit: '#',
-        value: ultimate.timesHitThreshold
-    });
-    data.push({
-        name: 'reduction (characters)',
-        unit: '#',
-        value: ultimate.reduction.numberOfCharacters.mean,
-        extra: `std: ${ultimate.reduction.numberOfCharacters.std}`
-    });
-    data.push({
-        name: 'reduction (normalized tokens)',
-        unit: '#',
-        value: ultimate.reduction.numberOfNormalizedTokens.mean,
-        extra: `std: ${ultimate.reduction.numberOfNormalizedTokens.std}`
-    });
-    // write the output file
-    fs_1.default.writeFileSync(outputGraphPath, JSON.stringify(data, json_1.jsonReplacer));
-}
-exports.writeGraphOutput = writeGraphOutput;
-//# sourceMappingURL=graph.js.map

package/util/summarizer/benchmark/second-phase/process.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="node" />
-import type { SummarizedSlicerStats, UltimateSlicerStats } from '../data';
-export declare function summarizeAllSummarizedStats(stats: SummarizedSlicerStats[]): UltimateSlicerStats;
-export declare function summarizeAllUltimateStats(stats: UltimateSlicerStats[]): UltimateSlicerStats;
-export declare function processNextSummary(line: Buffer, allSummarized: SummarizedSlicerStats[]): void;
-export declare function processNextUltimateSummary(line: Buffer, allSummarized: UltimateSlicerStats[]): void;

package/util/summarizer/benchmark/second-phase/process.js

@@ -1,126 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processNextUltimateSummary = exports.processNextSummary = exports.summarizeAllUltimateStats = exports.summarizeAllSummarizedStats = void 0;
-const defaultmap_1 = require("../../../defaultmap");
-const benchmark_1 = require("../../../../benchmark");
-const assert_1 = require("../../../assert");
-const process_1 = require("../first-phase/process");
-function summarizeAllSummarizedStats(stats) {
-    const commonMeasurements = new defaultmap_1.DefaultMap(() => []);
-    const perSliceMeasurements = new defaultmap_1.DefaultMap(() => []);
-    const reductions = [];
-    const inputs = [];
-    const dataflows = [];
-    let failedToRepParse = 0;
-    let timesHitThreshold = 0;
-    let totalSlices = 0;
-    for (const stat of stats) {
-        for (const [k, v] of stat.commonMeasurements) {
-            commonMeasurements.get(k).push(Number(v));
-        }
-        for (const [k, v] of stat.perSliceMeasurements.measurements) {
-            perSliceMeasurements.get(k).push(v);
-        }
-        reductions.push(stat.perSliceMeasurements.reduction);
-        inputs.push(stat.input);
-        dataflows.push(stat.dataflow);
-        failedToRepParse += stat.perSliceMeasurements.failedToRepParse;
-        totalSlices += stat.perSliceMeasurements.numberOfSlices;
-        timesHitThreshold += stat.perSliceMeasurements.timesHitThreshold;
-    }
-    return {
-        totalRequests: stats.length,
-        totalSlices: totalSlices,
-        commonMeasurements: new Map([...commonMeasurements.entries()].map(([k, v]) => [k, (0, benchmark_1.summarizeMeasurement)(v)])),
-        perSliceMeasurements: new Map([...perSliceMeasurements.entries()].map(([k, v]) => [k, (0, benchmark_1.summarizeSummarizedMeasurement)(v)])),
-        failedToRepParse,
-        timesHitThreshold,
-        reduction: (0, process_1.summarizeReductions)(reductions),
-        input: {
-            numberOfLines: (0, benchmark_1.summarizeMeasurement)(inputs.map(i => i.numberOfLines)),
-            numberOfCharacters: (0, benchmark_1.summarizeMeasurement)(inputs.map(i => i.numberOfCharacters)),
-            numberOfNonWhitespaceCharacters: (0, benchmark_1.summarizeMeasurement)(inputs.map(i => i.numberOfNonWhitespaceCharacters)),
-            numberOfRTokens: (0, benchmark_1.summarizeMeasurement)(inputs.map(i => i.numberOfRTokens)),
-            numberOfNormalizedTokens: (0, benchmark_1.summarizeMeasurement)(inputs.map(i => i.numberOfNormalizedTokens))
-        },
-        dataflow: {
-            numberOfNodes: (0, benchmark_1.summarizeMeasurement)(dataflows.map(d => d.numberOfNodes)),
-            numberOfFunctionDefinitions: (0, benchmark_1.summarizeMeasurement)(dataflows.map(d => d.numberOfFunctionDefinitions)),
-            numberOfCalls: (0, benchmark_1.summarizeMeasurement)(dataflows.map(d => d.numberOfCalls)),
-            numberOfEdges: (0, benchmark_1.summarizeMeasurement)(dataflows.map(d => d.numberOfEdges))
-        }
-    };
-}
-exports.summarizeAllSummarizedStats = summarizeAllSummarizedStats;
-function summarizeAllUltimateStats(stats) {
-    return {
-        // these should be deterministic, so we don't technically need to use max, but we do just in case something unexpected happens :)
-        totalRequests: Math.max(...stats.map(s => s.totalRequests)),
-        totalSlices: Math.max(...stats.map(s => s.totalSlices)),
-        failedToRepParse: Math.max(...stats.map(s => s.failedToRepParse)),
-        timesHitThreshold: Math.max(...stats.map(s => s.timesHitThreshold)),
-        // average out / summarize other measurements
-        commonMeasurements: new Map(benchmark_1.CommonSlicerMeasurements.map(m => [m, (0, benchmark_1.summarizeSummarizedMeasurement)(stats.map(s => s.commonMeasurements.get(m)))])),
-        perSliceMeasurements: new Map(benchmark_1.PerSliceMeasurements.map(m => [m, (0, benchmark_1.summarizeSummarizedMeasurement)(stats.map(s => s.perSliceMeasurements.get(m)))])),
-        reduction: (0, process_1.summarizeReductions)(stats.map(s => s.reduction)),
-        input: {
-            numberOfLines: (0, benchmark_1.summarizeSummarizedMeasurement)(stats.map(s => s.input.numberOfLines)),
-            numberOfCharacters: (0, benchmark_1.summarizeSummarizedMeasurement)(stats.map(s => s.input.numberOfCharacters)),
-            numberOfNonWhitespaceCharacters: (0, benchmark_1.summarizeSummarizedMeasurement)(stats.map(s => s.input.numberOfNonWhitespaceCharacters)),
-            numberOfRTokens: (0, benchmark_1.summarizeSummarizedMeasurement)(stats.map(s => s.input.numberOfRTokens)),
-            numberOfNormalizedTokens: (0, benchmark_1.summarizeSummarizedMeasurement)(stats.map(s => s.input.numberOfNormalizedTokens))
-        },
-        dataflow: {
-            numberOfNodes: (0, benchmark_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataflow.numberOfNodes)),
-            numberOfFunctionDefinitions: (0, benchmark_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataflow.numberOfFunctionDefinitions)),
-            numberOfCalls: (0, benchmark_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataflow.numberOfCalls)),
-            numberOfEdges: (0, benchmark_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataflow.numberOfEdges))
-        }
-    };
-}
-exports.summarizeAllUltimateStats = summarizeAllUltimateStats;
-function processNextSummary(line, allSummarized) {
-    let got = JSON.parse(line.toString());
-    got = {
-        summarize: {
-            input: got.summarize.input,
-            request: got.summarize.request,
-            dataflow: got.summarize.dataflow,
-            commonMeasurements: new Map(got.summarize.commonMeasurements
-                .map(([k, v]) => {
-                (0, assert_1.guard)(v.endsWith('n'), 'Expected a bigint');
-                return [k, BigInt(v.slice(0, -1))];
-            })),
-            perSliceMeasurements: {
-                numberOfSlices: got.summarize.perSliceMeasurements.numberOfSlices,
-                sliceCriteriaSizes: got.summarize.perSliceMeasurements.sliceCriteriaSizes,
-                measurements: new Map(got.summarize.perSliceMeasurements.measurements),
-                reduction: got.summarize.perSliceMeasurements.reduction,
-                timesHitThreshold: got.summarize.perSliceMeasurements.timesHitThreshold,
-                failedToRepParse: got.summarize.perSliceMeasurements.failedToRepParse,
-                sliceSize: got.summarize.perSliceMeasurements.sliceSize
-            }
-        }
-    };
-    allSummarized.push(got.summarize);
-}
-exports.processNextSummary = processNextSummary;
-function processNextUltimateSummary(line, allSummarized) {
-    let got = JSON.parse(line.toString());
-    got = {
-        summarize: {
-            totalRequests: got.summarize.totalRequests,
-            totalSlices: got.summarize.totalSlices,
-            commonMeasurements: new Map(got.summarize.commonMeasurements),
-            perSliceMeasurements: new Map(got.summarize.perSliceMeasurements),
-            failedToRepParse: got.summarize.failedToRepParse,
-            timesHitThreshold: got.summarize.timesHitThreshold,
-            reduction: got.summarize.reduction,
-            input: got.summarize.input,
-            dataflow: got.summarize.dataflow,
-        }
-    };
-    allSummarized.push(got.summarize);
-}
-exports.processNextUltimateSummary = processNextUltimateSummary;
-//# sourceMappingURL=process.js.map

package/util/summarizer/benchmark/summarizer.d.ts

@@ -1,31 +0,0 @@
-/**
- * This module is tasked with processing the results of the benchmarking (see {@link SlicerStats}).
- * @module
- */
-import type { CommonSummarizerConfiguration } from '../summarizer';
-import { Summarizer } from '../summarizer';
-import type { UltimateSlicerStats } from './data';
-export interface BenchmarkSummarizerConfiguration extends CommonSummarizerConfiguration {
-    /**
-     * If given, produce graph data output (e.g. for the benchmark visualization) to the given path
-     */
-    graphOutputPath?: string;
-    /**
-     * The input path to read from
-     */
-    inputPath: string;
-    /**
-     * Path for the intermediate results of the preparation phase
-     */
-    intermediateOutputPath: string;
-    /**
-     * Path for the final results of the summarization phase
-     */
-    outputPath: string;
-}
-export declare class BenchmarkSummarizer extends Summarizer<UltimateSlicerStats, BenchmarkSummarizerConfiguration> {
-    constructor(config: BenchmarkSummarizerConfiguration);
-    preparationPhase(): Promise<void>;
-    summarizePhase(): Promise<UltimateSlicerStats>;
-    private removeIfExists;
-}

package/util/summarizer/benchmark/summarizer.js

@@ -1,58 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BenchmarkSummarizer = void 0;
-const summarizer_1 = require("../summarizer");
-const fs_1 = __importDefault(require("fs"));
-const input_1 = require("./first-phase/input");
-const json_1 = require("../../json");
-const benchmark_1 = require("../../../benchmark");
-const process_1 = require("./second-phase/process");
-const graph_1 = require("./second-phase/graph");
-const files_1 = require("../../files");
-const path_1 = __importDefault(require("path"));
-class BenchmarkSummarizer extends summarizer_1.Summarizer {
-    constructor(config) {
-        super(config);
-    }
-    async preparationPhase() {
-        this.removeIfExists(`${this.config.intermediateOutputPath}.json`);
-        this.removeIfExists(this.config.intermediateOutputPath);
-        fs_1.default.mkdirSync(this.config.intermediateOutputPath);
-        const dirContent = fs_1.default.readdirSync(this.config.inputPath);
-        for (let i = 0; i < dirContent.length; i++) {
-            const filePath = path_1.default.join(this.config.inputPath, dirContent[i]);
-            const outputPath = path_1.default.join(this.config.intermediateOutputPath, dirContent[i]);
-            // generate measurements for each run
-            await (0, files_1.readLineByLine)(filePath, (line, lineNumber) => (0, input_1.processRunMeasurement)(line, i, lineNumber, `${outputPath}.log`, outputPath));
-            // generate combined measurements for the file
-            (0, input_1.processSummarizedFileMeasurement)(filePath, outputPath, `${this.config.intermediateOutputPath}.json`);
-        }
-        this.log('Done summarizing');
-    }
-    // eslint-disable-next-line @typescript-eslint/require-await -- just to obey the structure
-    async summarizePhase() {
-        this.log(`Summarizing all summaries from ${this.config.inputPath}...`);
-        this.removeIfExists(this.config.outputPath);
-        const summaries = [];
-        (0, files_1.readLineByLineSync)(`${this.config.intermediateOutputPath}.json`, (l) => (0, process_1.processNextUltimateSummary)(l, summaries));
-        const ultimate = (0, process_1.summarizeAllUltimateStats)(summaries);
-        this.log(`Writing ultimate summary to ${this.config.outputPath}`);
-        fs_1.default.writeFileSync(this.config.outputPath, JSON.stringify(ultimate, json_1.jsonReplacer));
-        console.log((0, benchmark_1.ultimateStats2String)(ultimate));
-        if (this.config.graphOutputPath) {
-            (0, graph_1.writeGraphOutput)(ultimate, this.config.graphOutputPath);
-        }
-        return ultimate;
-    }
-    removeIfExists(path) {
-        if (path && fs_1.default.existsSync(path)) {
-            this.log(`Removing existing ${path}`);
-            fs_1.default.rmSync(path, { recursive: true });
-        }
-    }
-}
-exports.BenchmarkSummarizer = BenchmarkSummarizer;
-//# sourceMappingURL=summarizer.js.map

package/util/summarizer/statistics/first-phase/process.d.ts

@@ -1,6 +0,0 @@
-export declare class FileMigrator {
-    private readonly writeHandles;
-    private finished;
-    migrate(sourceFolderContent: Map<string, string>, targetFolder: string, originalFile: string | undefined): Promise<void>;
-    finish(): void;
-}

package/util/summarizer/statistics/first-phase/process.js

@@ -1,81 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileMigrator = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const assert_1 = require("../../../assert");
-class FileMigrator {
-    writeHandles = new Map();
-    finished = false;
-    async migrate(sourceFolderContent, targetFolder, originalFile) {
-        (0, assert_1.guard)(!this.finished, () => 'migrator is already marked as finished!');
-        if (!fs_1.default.existsSync(targetFolder)) {
-            fs_1.default.mkdirSync(targetFolder, { recursive: true });
-        }
-        const promises = [];
-        for (const [filepath, content] of sourceFolderContent.entries()) {
-            const target = path_1.default.join(targetFolder, filepath);
-            let targetStream = this.writeHandles.get(target);
-            if (targetStream === undefined) {
-                if (!fs_1.default.existsSync(path_1.default.dirname(target))) {
-                    fs_1.default.mkdirSync(path_1.default.dirname(target), { recursive: true });
-                }
-                targetStream = fs_1.default.createWriteStream(target, { flags: 'a' });
-                this.writeHandles.set(target, targetStream);
-            }
-            // before we write said content we have to group {value: string, context: string} by context (while we can safely assume that there is only one context per file,
-            // i want to be sure
-            let data;
-            // regex matches failed due to encoding errors
-            if (filepath.endsWith('meta/stats.txt') || filepath.endsWith('meta/features.txt')) {
-                data = `{"file":"${originalFile ?? ''}","content":${content.trimEnd()}}\n`;
-            }
-            else {
-                const grouped = groupByContext(content);
-                data = grouped === undefined ? content : grouped.map(s => JSON.stringify(s)).join('\n') + '\n';
-            }
-            promises.push(new Promise((resolve, reject) => targetStream.write(data, 'utf-8', err => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve();
-                }
-            })));
-        }
-        await Promise.all(promises);
-    }
-    finish() {
-        for (const handle of this.writeHandles.values()) {
-            handle.close();
-        }
-        this.finished = true;
-    }
-}
-exports.FileMigrator = FileMigrator;
-function groupByContext(input) {
-    if (input === undefined) {
-        return [];
-    }
-    const parsed = input.split('\n').filter(s => s && s !== '').map(s => JSON.parse(s));
-    const grouped = new Map();
-    for (const content of parsed) {
-        if (!Array.isArray(content)) {
-            // in this case it is a meta file or other which does not have to be grouped
-            return undefined;
-        }
-        const [value, context] = content;
-        const get = grouped.get(context);
-        if (get === undefined) {
-            grouped.set(context, [value]);
-        }
-        else {
-            get.push(value);
-        }
-    }
-    return [...grouped.entries()].map(([context, values]) => [values, context]);
-}
-//# sourceMappingURL=process.js.map

package/util/summarizer/statistics/post-process/clusterer.d.ts

@@ -1,26 +0,0 @@
-import { DefaultMap } from '../../../defaultmap';
-import type { NodeId } from '../../../../r-bridge';
-import type { MergeableRecord } from '../../../objects';
-export type ContextsWithCount = DefaultMap<NodeId, number>;
-export type ClusterContextIdMap = DefaultMap<string | undefined, NodeId>;
-export type ClusterValueInfoMap = DefaultMap<string, ContextsWithCount>;
-/** Produced by {@link clusterStatisticsOutput} */
-export interface ClusterReport extends MergeableRecord {
-    /** The input file which has been clustered */
-    readonly filepath: string;
-    /** Maps each context encountered (i.e., every file which contains something associated with the feature) to a unique id, used in the {@link ClusterReport#valueInfoMap | valueInfoMap}. */
-    contextIdMap: ClusterContextIdMap;
-    /**
-   * Counts which contexts contained which values of a feature.
-   * For example, that `<-` occurred in files with ids `[12, 42, 19, 19]` (i.e., the context with the id 19 contained it twice).
-   */
-    valueInfoMap: ClusterValueInfoMap;
-}
-/**
- * Takes a statistics file like `statistics-out/top-2023-01-01-00-00-00/Assignments/assignmentOperator.txt` and clusters the values by context
- *
- * @param filepath     - Filepath of the statistics file
- * @param contextIdMap - The id map to use, can use an existing one to reuse ids for same contexts spreading over multiple input files.
- *  `undefined` is used for unknown contexts. This map allows us to reference contexts with a way shorter identifier (vs. the full file path).
- */
-export declare function clusterStatisticsOutput(filepath: string, contextIdMap?: ClusterContextIdMap): ClusterReport;

package/util/summarizer/statistics/post-process/clusterer.js

@@ -1,43 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.clusterStatisticsOutput = void 0;
-/**
- * Reading the given file line by line and expecting constructs of {@link StatisticsOutputFormat},
- * this module is responsible for identifying interesting groups of same data.
- *
- * @module
- */
-const n_readlines_1 = __importDefault(require("n-readlines"));
-const defaultmap_1 = require("../../../defaultmap");
-const r_bridge_1 = require("../../../../r-bridge");
-/**
- * Takes a statistics file like `statistics-out/top-2023-01-01-00-00-00/Assignments/assignmentOperator.txt` and clusters the values by context
- *
- * @param filepath     - Filepath of the statistics file
- * @param contextIdMap - The id map to use, can use an existing one to reuse ids for same contexts spreading over multiple input files.
- *  `undefined` is used for unknown contexts. This map allows us to reference contexts with a way shorter identifier (vs. the full file path).
- */
-function clusterStatisticsOutput(filepath, contextIdMap = new defaultmap_1.DefaultMap((0, r_bridge_1.deterministicCountingIdGenerator)())) {
-    const lineReader = new n_readlines_1.default(filepath);
-    // for each value we store the context ids it was seen in (may list the same context multiple times if more often) - this serves as a counter as well
-    const valueInfoMap = new defaultmap_1.DefaultMap(() => new defaultmap_1.DefaultMap(() => 0));
-    let line;
-    // eslint-disable-next-line no-cond-assign
-    while (line = lineReader.next()) {
-        const json = JSON.parse(line.toString());
-        const contextId = contextIdMap.get(json[1]);
-        const value = valueInfoMap.get(json[0]);
-        // step the counter accordingly
-        value.set(contextId, value.get(contextId) + 1);
-    }
-    return {
-        filepath,
-        contextIdMap,
-        valueInfoMap
-    };
-}
-exports.clusterStatisticsOutput = clusterStatisticsOutput;
-//# sourceMappingURL=clusterer.js.map