@eagleoutice/flowr 2.2.16 → 2.4.0

package/benchmark/slicer.js

@@ -26,6 +26,10 @@ const tree_sitter_executor_1 = require("../r-bridge/lang-4.x/tree-sitter/tree-si
 const vertex_1 = require("../dataflow/graph/vertex");
 const arrays_1 = require("../util/collections/arrays");
 const config_1 = require("../config");
+const extract_cfg_1 = require("../control-flow/extract-cfg");
+const absint_info_1 = require("../abstract-interpretation/data-frame/absint-info");
+const domain_1 = require("../abstract-interpretation/data-frame/domain");
+const shape_inference_1 = require("../abstract-interpretation/data-frame/shape-inference");
 /**
  * The logger to be used for benchmarking as a global object.
  */
@@ -36,10 +40,12 @@ class BenchmarkSlicer {
     perSliceMeasurements = new Map();
     deltas = new Map();
     parserName;
+    config;
     stats;
     loadedXml;
     dataflow;
     normalizedAst;
+    controlFlow;
     totalStopwatch;
     finished = false;
     // Yes, this is unclean, but we know that we assign the executor during the initialization and this saves us from having to check for nullability every time
@@ -55,6 +61,7 @@ class BenchmarkSlicer {
      */
     async init(request, config, autoSelectIf, threshold) {
         (0, assert_1.guard)(this.stats === undefined, 'cannot initialize the slicer twice');
+        this.config = config;
         // we know these are in sync so we just cast to one of them
         this.parser = await this.commonMeasurements.measure('initialize R session', async () => {
             if (this.parserName === 'r-shell') {
@@ -258,6 +265,114 @@ class BenchmarkSlicer {
             code: stats.reconstructedCode
         };
     }
+    /**
+     * Extract the control flow graph using {@link extractCFG}
+     */
+    extractCFG() {
+        exports.benchmarkLogger.trace('try to extract the control flow graph');
+        this.guardActive();
+        (0, assert_1.guard)(this.normalizedAst !== undefined, 'normalizedAst should be defined for control flow extraction');
+        (0, assert_1.guard)(this.dataflow !== undefined, 'dataflow should be defined for control flow extraction');
+        (0, assert_1.guard)(this.config !== undefined, 'config should be defined for control flow extraction');
+        const ast = this.normalizedAst;
+        const dfg = this.dataflow.graph;
+        const config = this.config;
+        this.controlFlow = this.measureSimpleStep('extract control flow graph', () => (0, extract_cfg_1.extractCfg)(ast, config, dfg));
+    }
+    /**
+     * Infer the shape of data frames using abstract interpretation with {@link inferDataFrameShapes}
+     *
+     * @returns The statistics of the data frame shape inference
+     */
+    inferDataFrameShapes() {
+        exports.benchmarkLogger.trace('try to infer shapes for data frames');
+        (0, assert_1.guard)(this.stats !== undefined && !this.finished, 'need to call init before, and can not do after finish!');
+        (0, assert_1.guard)(this.normalizedAst !== undefined, 'normalizedAst should be defined for data frame shape inference');
+        (0, assert_1.guard)(this.dataflow !== undefined, 'dataflow should be defined for data frame shape inference');
+        (0, assert_1.guard)(this.controlFlow !== undefined, 'controlFlow should be defined for data frame shape inference');
+        (0, assert_1.guard)(this.config !== undefined, 'config should be defined for data frame shape inference');
+        const ast = this.normalizedAst;
+        const dfg = this.dataflow.graph;
+        const cfinfo = this.controlFlow;
+        const config = this.config;
+        const stats = {
+            numberOfDataFrameFiles: 0,
+            numberOfNonDataFrameFiles: 0,
+            numberOfResultConstraints: 0,
+            numberOfResultingValues: 0,
+            numberOfResultingTop: 0,
+            numberOfResultingBottom: 0,
+            numberOfEmptyNodes: 0,
+            numberOfOperationNodes: 0,
+            numberOfValueNodes: 0,
+            sizeOfInfo: 0,
+            perNodeStats: new Map()
+        };
+        const result = this.measureSimpleStep('infer data frame shapes', () => (0, shape_inference_1.inferDataFrameShapes)(cfinfo, dfg, ast, config));
+        stats.numberOfResultConstraints = result.size;
+        for (const value of result.values()) {
+            if ((0, domain_1.equalDataFrameDomain)(value, domain_1.DataFrameTop)) {
+                stats.numberOfResultingTop++;
+            }
+            else if ((0, domain_1.equalDataFrameDomain)(value, domain_1.DataFrameBottom)) {
+                stats.numberOfResultingBottom++;
+            }
+            else {
+                stats.numberOfResultingValues++;
+            }
+        }
+        (0, visitor_1.visitAst)(this.normalizedAst.ast, (node) => {
+            if (node.info.dataFrame === undefined) {
+                return;
+            }
+            stats.sizeOfInfo += (0, size_of_1.safeSizeOf)([node.info.dataFrame]);
+            const expression = (0, absint_info_1.hasDataFrameExpressionInfo)(node) ? node.info.dataFrame : undefined;
+            const value = node.info.dataFrame.domain?.get(node.info.id);
+            // Only store per-node information for nodes representing expressions or nodes with abstract values
+            if (expression === undefined && value === undefined) {
+                stats.numberOfEmptyNodes++;
+                return;
+            }
+            const nodeStats = {
+                numberOfEntries: node.info.dataFrame?.domain?.size ?? 0
+            };
+            if (expression !== undefined) {
+                nodeStats.mappedOperations = expression.operations.map(op => op.operation);
+                stats.numberOfOperationNodes++;
+                if (value !== undefined) {
+                    nodeStats.inferredColNames = value.colnames === domain_1.ColNamesTop ? 'top' : value.colnames.length;
+                    nodeStats.inferredColCount = this.getInferredSize(value.cols);
+                    nodeStats.inferredRowCount = this.getInferredSize(value.rows);
+                    nodeStats.approxRangeColCount = value.cols === domain_1.IntervalBottom ? 0 : value.cols[1] - value.cols[0];
+                    nodeStats.approxRangeRowCount = value.rows === domain_1.IntervalBottom ? 0 : value.rows[1] - value.rows[0];
+                }
+            }
+            if (value !== undefined) {
+                stats.numberOfValueNodes++;
+            }
+            stats.perNodeStats.set(node.info.id, nodeStats);
+        });
+        if (stats.numberOfOperationNodes > 0) {
+            stats.numberOfDataFrameFiles = 1;
+        }
+        else {
+            stats.numberOfNonDataFrameFiles = 1;
+        }
+        this.stats.dataFrameShape = stats;
+        return stats;
+    }
+    getInferredSize(value) {
+        if ((0, domain_1.equalInterval)(value, domain_1.IntervalTop)) {
+            return 'top';
+        }
+        else if (value === domain_1.IntervalBottom) {
+            return 'bottom';
+        }
+        else if (!isFinite(value[1])) {
+            return 'infinite';
+        }
+        return Math.floor((value[0] + value[1]) / 2);
+    }
     /** Bridging the gap between the new internal and the old names for the benchmarking */
     async measureCommonStep(expectedStep, keyToMeasure) {
         const memoryInit = process.memoryUsage();
@@ -271,6 +386,18 @@ class BenchmarkSlicer {
         });
         return result;
     }
+    measureSimpleStep(keyToMeasure, measurement) {
+        const memoryInit = process.memoryUsage();
+        const result = this.commonMeasurements.measure(keyToMeasure, measurement);
+        const memoryEnd = process.memoryUsage();
+        this.deltas.set(keyToMeasure, {
+            heap: memoryEnd.heapUsed - memoryInit.heapUsed,
+            rss: memoryEnd.rss - memoryInit.rss,
+            external: memoryEnd.external - memoryInit.external,
+            buffs: memoryEnd.arrayBuffers - memoryInit.arrayBuffers
+        });
+        return result;
+    }
     async measureSliceStep(expectedStep, measure, keyToMeasure) {
         const { result } = await measure.measureAsync(keyToMeasure, () => this.executor.nextStep(expectedStep));
         return result;
@@ -330,6 +457,8 @@ class BenchmarkSlicer {
         const retrieveTime = Number(this.stats.commonMeasurements.get('retrieve AST from R code'));
         const normalizeTime = Number(this.stats.commonMeasurements.get('normalize R AST'));
         const dataflowTime = Number(this.stats.commonMeasurements.get('produce dataflow information'));
+        const controlFlowTime = Number(this.stats.commonMeasurements.get('extract control flow graph'));
+        const dataFrameShapeTime = Number(this.stats.commonMeasurements.get('infer data frame shapes'));
         this.stats.retrieveTimePerToken = {
             raw: retrieveTime / this.stats.input.numberOfRTokens,
             normalized: retrieveTime / this.stats.input.numberOfNormalizedTokens
@@ -346,6 +475,14 @@ class BenchmarkSlicer {
             raw: (retrieveTime + normalizeTime + dataflowTime) / this.stats.input.numberOfRTokens,
             normalized: (retrieveTime + normalizeTime + dataflowTime) / this.stats.input.numberOfNormalizedTokens
         };
+        this.stats.controlFlowTimePerToken = !isNaN(controlFlowTime) ? {
+            raw: controlFlowTime / this.stats.input.numberOfRTokens,
+            normalized: controlFlowTime / this.stats.input.numberOfNormalizedTokens,
+        } : undefined;
+        this.stats.dataFrameShapeTimePerToken = !isNaN(dataFrameShapeTime) ? {
+            raw: dataFrameShapeTime / this.stats.input.numberOfRTokens,
+            normalized: dataFrameShapeTime / this.stats.input.numberOfNormalizedTokens,
+        } : undefined;
         return {
             stats: this.stats,
             parse: typeof this.loadedXml === 'string' ? this.loadedXml : JSON.stringify(this.loadedXml),

package/benchmark/stats/print.js

@@ -84,22 +84,34 @@ function convertNumberToNiceBytes(x) {
 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 retrieval per token:      ${formatNanoseconds(stats.retrieveTimePerToken.normalized)}
-AST retrieval per R token:    ${formatNanoseconds(stats.retrieveTimePerToken.raw)}
-AST normalization:            ${print(stats.commonMeasurements, 'normalize R AST')}
-AST normalization per token:  ${formatNanoseconds(stats.normalizeTimePerToken.normalized)}
-AST normalization per R token:${formatNanoseconds(stats.normalizeTimePerToken.raw)}
-Dataflow creation:            ${print(stats.commonMeasurements, 'produce dataflow information')}
-Dataflow creation per token:  ${formatNanoseconds(stats.dataflowTimePerToken.normalized)}
-Dataflow creation per R token:${formatNanoseconds(stats.dataflowTimePerToken.raw)}
-Total common time per token:  ${formatNanoseconds(stats.totalCommonTimePerToken.normalized)}
-Total common time per R token:${formatNanoseconds(stats.totalCommonTimePerToken.raw)}
-
-Slicing summary for ${stats.perSliceMeasurements.numberOfSlices} slice${stats.perSliceMeasurements.numberOfSlices !== 1 ? 's' : ''}:`;
+Shell init time:                      ${print(stats.commonMeasurements, 'initialize R session')}
+AST retrieval:                        ${print(stats.commonMeasurements, 'retrieve AST from R code')}
+AST retrieval per token:              ${formatNanoseconds(stats.retrieveTimePerToken.normalized)}
+AST retrieval per R token:            ${formatNanoseconds(stats.retrieveTimePerToken.raw)}
+AST normalization:                    ${print(stats.commonMeasurements, 'normalize R AST')}
+AST normalization per token:          ${formatNanoseconds(stats.normalizeTimePerToken.normalized)}
+AST normalization per R token:        ${formatNanoseconds(stats.normalizeTimePerToken.raw)}
+Dataflow creation:                    ${print(stats.commonMeasurements, 'produce dataflow information')}
+Dataflow creation per token:          ${formatNanoseconds(stats.dataflowTimePerToken.normalized)}
+Dataflow creation per R token:        ${formatNanoseconds(stats.dataflowTimePerToken.raw)}
+Total common time per token:          ${formatNanoseconds(stats.totalCommonTimePerToken.normalized)}
+Total common time per R token:        ${formatNanoseconds(stats.totalCommonTimePerToken.raw)}`;
+    if (stats.commonMeasurements.has('extract control flow graph') && stats.controlFlowTimePerToken !== undefined) {
+        result += `
+Control flow extraction:              ${print(stats.commonMeasurements, 'extract control flow graph')}
+Control flow extraction per token:    ${formatNanoseconds(stats.controlFlowTimePerToken.normalized)}
+Control flow extraction per R token:  ${formatNanoseconds(stats.controlFlowTimePerToken.raw)}`;
+    }
+    if (stats.commonMeasurements.has('infer data frame shapes') && stats.dataFrameShapeTimePerToken !== undefined) {
+        result += `
+Dataframe shape inference:            ${print(stats.commonMeasurements, 'infer data frame shapes')}
+Dataframe shape inference per token:  ${formatNanoseconds(stats.dataFrameShapeTimePerToken.normalized)}
+Dataframe shape inference per R token:${formatNanoseconds(stats.dataFrameShapeTimePerToken.raw)}`;
+    }
     if (stats.perSliceMeasurements.numberOfSlices > 0) {
         result += `
+
+Slicing summary for ${stats.perSliceMeasurements.numberOfSlices} slice${stats.perSliceMeasurements.numberOfSlices !== 1 ? 's' : ''}:
   Total:                              ${printSummarizedMeasurements(stats.perSliceMeasurements, 'total')}
   Slice creation:                     ${printSummarizedMeasurements(stats.perSliceMeasurements, 'static slicing')}
   Slice creation per token in slice:  ${formatSummarizedTimeMeasure(stats.perSliceMeasurements.sliceTimePerToken.normalized)}
@@ -110,7 +122,7 @@ Slicing summary for ${stats.perSliceMeasurements.numberOfSlices} slice${stats.pe
   Total per token in slice:           ${formatSummarizedTimeMeasure(stats.perSliceMeasurements.totalPerSliceTimePerToken.normalized)}
   Total per R token in slice:         ${formatSummarizedTimeMeasure(stats.perSliceMeasurements.totalPerSliceTimePerToken.raw)}
   Used Slice Criteria Sizes:          ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceCriteriaSizes)}
-  Result Slice Sizes:   
+  Result Slice Sizes:
     Number of lines:                     ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.lines)}
     Number of non-empty lines:           ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.nonEmptyLines)}
     Number of characters:                ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.characters)}
@@ -120,12 +132,12 @@ Slicing summary for ${stats.perSliceMeasurements.numberOfSlices} slice${stats.pe
     Number of R tokens (w/o comments):   ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.tokensNoComments)}
     Normalized R tokens:                 ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.normalizedTokens)}
     Normalized R tokens (w/o comments):  ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.normalizedTokensNoComments)}
-    Number of dataflow nodes:            ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.dataflowNodes)}
-`;
+    Number of dataflow nodes:            ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.dataflowNodes)}`;
     }
-    return `${result}
-Shell close:                  ${print(stats.commonMeasurements, 'close R session')}
-Total:                        ${print(stats.commonMeasurements, 'total')}
+    result += `
+
+Shell close:                         ${print(stats.commonMeasurements, 'close R session')}
+Total:                               ${print(stats.commonMeasurements, 'total')}
 
 Input:
   Number of lines:                     ${pad(stats.input.numberOfLines)}
@@ -148,9 +160,64 @@ Dataflow:
   Number of stored Env indices:  ${pad(stats.dataflow.storedEnvIndices)}
   Number of overwritten indices: ${pad(stats.dataflow.overwrittenIndices)}
   Size of graph:                 ${convertNumberToNiceBytes(stats.dataflow.sizeOfObject)}`;
+    if (stats.dataFrameShape !== undefined) {
+        result += `
+
+Dataframe shape inference:
+  Number of resulting constraints:${pad(stats.dataFrameShape.numberOfResultConstraints)}
+  Number of operation nodes:      ${pad(stats.dataFrameShape.numberOfOperationNodes)}
+  Number of abstract value nodes: ${pad(stats.dataFrameShape.numberOfValueNodes)}
+  Number of entries per node:     ${pad(stats.dataFrameShape.numberOfEntriesPerNode.mean)}
+  Number of operations:           ${pad(stats.dataFrameShape.numberOfOperations)}
+  Number of total values:         ${pad(stats.dataFrameShape.numberOfTotalValues)}
+  Number of total top:            ${pad(stats.dataFrameShape.numberOfTotalTop)}
+  Inferred column names per node: ${pad(stats.dataFrameShape.inferredColNames.mean)}
+  Number of column names values:  ${pad(stats.dataFrameShape.numberOfColNamesValues)}
+  Number of column names Top:     ${pad(stats.dataFrameShape.numberOfColNamesTop)}
+  Inferred column count per node: ${pad(stats.dataFrameShape.inferredColCount.mean)}
+  Number of column count values:  ${pad(stats.dataFrameShape.numberOfColCountValues)}
+  Number of column count Top:     ${pad(stats.dataFrameShape.numberOfColCountTop)}
+  Number of column count infinite:${pad(stats.dataFrameShape.numberOfColCountInfinite)}
+  Inferred row count per node:    ${pad(stats.dataFrameShape.inferredRowCount.mean)}
+  Number of row count values:     ${pad(stats.dataFrameShape.numberOfRowCountValues)}
+  Number of row count Top:        ${pad(stats.dataFrameShape.numberOfRowCountTop)}
+  Number of row count infinite:   ${pad(stats.dataFrameShape.numberOfRowCountInfinite)}
+  Size of data frame shape info:  ${convertNumberToNiceBytes(stats.dataFrameShape.sizeOfInfo)}`;
+    }
+    return result;
 }
 function ultimateStats2String(stats) {
-    const slice = stats.totalSlices > 0 ? `Slice summary for:
+    let result = `
+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 retrieval per token:              ${formatSummarizedTimeMeasure(stats.retrieveTimePerToken.normalized)}
+AST retrieval per R token:            ${formatSummarizedTimeMeasure(stats.retrieveTimePerToken.raw)}
+AST normalization:                    ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('normalize R AST'))}
+AST normalization per token:          ${formatSummarizedTimeMeasure(stats.normalizeTimePerToken.normalized)}
+AST normalization per R token:        ${formatSummarizedTimeMeasure(stats.normalizeTimePerToken.raw)}
+Dataflow creation:                    ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('produce dataflow information'))}
+Dataflow creation per token:          ${formatSummarizedTimeMeasure(stats.dataflowTimePerToken.normalized)}
+Dataflow creation per R token:        ${formatSummarizedTimeMeasure(stats.dataflowTimePerToken.raw)}
+Total common time per token:          ${formatSummarizedTimeMeasure(stats.totalCommonTimePerToken.normalized)}
+Total common time per R token:        ${formatSummarizedTimeMeasure(stats.totalCommonTimePerToken.raw)}`;
+    if (stats.commonMeasurements.has('extract control flow graph') && stats.controlFlowTimePerToken !== undefined) {
+        result += `
+Control flow extraction:              ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('extract control flow graph'))}
+Control flow extraction per token:    ${formatSummarizedTimeMeasure(stats.controlFlowTimePerToken.normalized)}
+Control flow extraction per R token:  ${formatSummarizedTimeMeasure(stats.controlFlowTimePerToken.raw)}`;
+    }
+    if (stats.commonMeasurements.has('infer data frame shapes') && stats.dataFrameShapeTimePerToken !== undefined) {
+        result += `
+Dataframe shape inference:            ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('infer data frame shapes'))}
+Dataframe shape inference per token:  ${formatSummarizedTimeMeasure(stats.dataFrameShapeTimePerToken.normalized)}
+Dataframe shape inference per R token:${formatSummarizedTimeMeasure(stats.dataFrameShapeTimePerToken.raw)}`;
+    }
+    // Used Slice Criteria Sizes: ${formatSummarizedMeasure(stats.perSliceMeasurements.sliceCriteriaSizes)}
+    if (stats.totalSlices > 0) {
+        result += `
+
+Slicing summary for ${stats.totalSlices} slice${stats.totalSlices !== 1 ? 's' : ''}:
   Total:                              ${formatSummarizedTimeMeasure(stats.perSliceMeasurements.get('total'))}
   Slice creation:                     ${formatSummarizedTimeMeasure(stats.perSliceMeasurements.get('static slicing'))}
   Slice creation per token in slice:  ${formatSummarizedTimeMeasure(stats.sliceTimePerToken.normalized)}
@@ -161,29 +228,14 @@ function ultimateStats2String(stats) {
   Total per token in slice:           ${formatSummarizedTimeMeasure(stats.totalPerSliceTimePerToken.normalized)}
   Total per R token in slice:         ${formatSummarizedTimeMeasure(stats.totalPerSliceTimePerToken.raw)}
   Failed to Re-Parse:                 ${pad(stats.failedToRepParse)}/${stats.totalSlices}
-  Times hit Threshold:                ${pad(stats.timesHitThreshold)}/${stats.totalSlices} 
+  Times hit Threshold:                ${pad(stats.timesHitThreshold)}/${stats.totalSlices}
 ${reduction2String('Reductions', stats.reduction)}
-${reduction2String('Reductions without comments and empty lines', stats.reductionNoFluff)}` : 'No slices';
-    // 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 retrieval per token:      ${formatSummarizedTimeMeasure(stats.retrieveTimePerToken.normalized)}
-AST retrieval per R token:    ${formatSummarizedTimeMeasure(stats.retrieveTimePerToken.raw)}
-AST normalization:            ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('normalize R AST'))}
-AST normalization per token:  ${formatSummarizedTimeMeasure(stats.normalizeTimePerToken.normalized)}
-AST normalization per R token:${formatSummarizedTimeMeasure(stats.normalizeTimePerToken.raw)}
-Dataflow creation:            ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('produce dataflow information'))}
-Dataflow creation per token:  ${formatSummarizedTimeMeasure(stats.dataflowTimePerToken.normalized)}
-Dataflow creation per R token:${formatSummarizedTimeMeasure(stats.dataflowTimePerToken.raw)}
-Total common time per token:  ${formatSummarizedTimeMeasure(stats.totalCommonTimePerToken.normalized)}
-Total common time per R token:${formatSummarizedTimeMeasure(stats.totalCommonTimePerToken.raw)}
-
-${slice}
+${reduction2String('Reductions without comments and empty lines', stats.reductionNoFluff)}`;
+    }
+    result += `
 
-Shell close:                  ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('close R session'))}
-Total:                        ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('total'))}
+Shell close:                        ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('close R session'))}
+Total:                              ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('total'))}
 
 Input:
   Number of lines:                     ${formatSummarizedMeasure(stats.input.numberOfLines)}
@@ -205,12 +257,38 @@ Dataflow:
   Number of stored Vtx indices:  ${formatSummarizedMeasure(stats.dataflow.storedVertexIndices)}
   Number of stored Env indices:  ${formatSummarizedMeasure(stats.dataflow.storedEnvIndices)}
   Number of overwritten indices: ${formatSummarizedMeasure(stats.dataflow.overwrittenIndices)}
-  Size of graph:                 ${formatSummarizedMeasure(stats.dataflow.sizeOfObject, convertNumberToNiceBytes)}
-`;
+  Size of graph:                 ${formatSummarizedMeasure(stats.dataflow.sizeOfObject, convertNumberToNiceBytes)}`;
+    if (stats.dataFrameShape !== undefined) {
+        result += `
+
+Dataframe shape inference:
+  Number of resulting constraints:${formatSummarizedMeasure(stats.dataFrameShape.numberOfResultConstraints)}
+  Number of operation nodes:      ${formatSummarizedMeasure(stats.dataFrameShape.numberOfOperationNodes)}
+  Number of abstract value nodes: ${formatSummarizedMeasure(stats.dataFrameShape.numberOfValueNodes)}
+  Number of entries per node:     ${formatSummarizedMeasure(stats.dataFrameShape.numberOfEntriesPerNode)}
+  Number of operations:           ${formatSummarizedMeasure(stats.dataFrameShape.numberOfOperations)}
+  Number of total values:         ${formatSummarizedMeasure(stats.dataFrameShape.numberOfTotalValues)}
+  Number of total top:            ${formatSummarizedMeasure(stats.dataFrameShape.numberOfTotalTop)}
+  Inferred column names per node: ${formatSummarizedMeasure(stats.dataFrameShape.inferredColNames)}
+  Number of column names values:  ${formatSummarizedMeasure(stats.dataFrameShape.numberOfColNamesValues)}
+  Number of column names top:     ${formatSummarizedMeasure(stats.dataFrameShape.numberOfColNamesTop)}
+  Inferred column count per node: ${formatSummarizedMeasure(stats.dataFrameShape.inferredColCount)}
+  Number of column count exact:   ${formatSummarizedMeasure(stats.dataFrameShape.numberOfColCountExact)}
+  Number of column count values:  ${formatSummarizedMeasure(stats.dataFrameShape.numberOfColCountValues)}
+  Number of column count top:     ${formatSummarizedMeasure(stats.dataFrameShape.numberOfColCountTop)}
+  Number of column count infinite:${formatSummarizedMeasure(stats.dataFrameShape.numberOfColCountInfinite)}
+  Inferred row count per node:    ${formatSummarizedMeasure(stats.dataFrameShape.inferredRowCount)}
+  Number of row count exact:      ${formatSummarizedMeasure(stats.dataFrameShape.numberOfRowCountExact)}
+  Number of row count values:     ${formatSummarizedMeasure(stats.dataFrameShape.numberOfRowCountValues)}
+  Number of row count top:        ${formatSummarizedMeasure(stats.dataFrameShape.numberOfRowCountTop)}
+  Number of row count infinite:   ${formatSummarizedMeasure(stats.dataFrameShape.numberOfRowCountInfinite)}
+  Size of data frame shape info:  ${formatSummarizedMeasure(stats.dataFrameShape.sizeOfInfo, convertNumberToNiceBytes)}`;
+    }
+    return result;
 }
 function reduction2String(title, reduction) {
     return `
-  ${title} (reduced by x%):   
+  ${title} (reduced by x%):
     Number of lines:                     ${formatSummarizedMeasure(reduction.numberOfLines, asPercentage)}
     Number of lines no auto:             ${formatSummarizedMeasure(reduction.numberOfLinesNoAutoSelection, asPercentage)}
     Number of characters:                ${formatSummarizedMeasure(reduction.numberOfCharacters, asPercentage)}

package/benchmark/stats/size-of.d.ts

@@ -1,3 +1,10 @@
 import type { DataflowGraph } from '../../dataflow/graph/graph';
 /** Returns the size of the given df graph in bytes (without sharing in-memory) */
 export declare function getSizeOfDfGraph(df: DataflowGraph): number;
+/**
+ * Calculates the size of an array in bytes.
+ *
+ * @param array - The array to calculate the size of.
+ * @returns The size of the array in bytes.
+ */
+export declare function safeSizeOf<T>(array: T[]): number;

package/benchmark/stats/size-of.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSizeOfDfGraph = getSizeOfDfGraph;
+exports.safeSizeOf = safeSizeOf;
 const environment_1 = require("../../dataflow/environments/environment");
 const vertex_1 = require("../../dataflow/graph/vertex");
 const identifier_1 = require("../../dataflow/environments/identifier");

package/benchmark/stats/stats.d.ts

@@ -4,7 +4,10 @@ import type { ReconstructionResult } from '../../reconstruct/reconstruct';
 import type { RParseRequestFromFile, RParseRequestFromText } from '../../r-bridge/retriever';
 import type { TimePerToken } from '../summarizer/data';
 import type { MergeableRecord } from '../../util/objects';
-export declare const CommonSlicerMeasurements: readonly ["initialize R session", "retrieve AST from R code", "normalize R AST", "produce dataflow information", "close R session", "total"];
+import type { DataFrameOperationName } from '../../abstract-interpretation/data-frame/semantics';
+export declare const RequiredSlicerMeasurements: readonly ["initialize R session", "retrieve AST from R code", "normalize R AST", "produce dataflow information", "close R session", "total"];
+export declare const OptionalSlicerMeasurements: readonly ["extract control flow graph", "infer data frame shapes"];
+export declare const CommonSlicerMeasurements: readonly ["initialize R session", "retrieve AST from R code", "normalize R AST", "produce dataflow information", "close R session", "total", "extract control flow graph", "infer data frame shapes"];
 export type CommonSlicerMeasurements = typeof CommonSlicerMeasurements[number];
 export declare const PerSliceMeasurements: readonly ["static slicing", "reconstruct code", "total"];
 export type PerSliceMeasurements = typeof PerSliceMeasurements[number];
@@ -41,6 +44,29 @@ export interface SlicerStatsDataflow<T = number> {
     storedEnvIndices: T;
     overwrittenIndices: T;
 }
+export interface SlicerStatsDfShape<T = number> {
+    numberOfDataFrameFiles: T extends number ? 0 | 1 : number;
+    numberOfNonDataFrameFiles: T extends number ? 0 | 1 : number;
+    numberOfResultConstraints: T;
+    numberOfResultingValues: T;
+    numberOfResultingTop: T;
+    numberOfResultingBottom: T;
+    numberOfEmptyNodes: T;
+    numberOfOperationNodes: T;
+    numberOfValueNodes: T;
+    sizeOfInfo: T;
+    perNodeStats: Map<NodeId, PerNodeStatsDfShape<T>>;
+}
+export interface PerNodeStatsDfShape<T = number> {
+    numberOfEntries: T;
+    mappedOperations?: DataFrameOperationName[];
+    inferredColNames?: T | 'top';
+    inferredColCount?: T | 'bottom' | 'infinite' | 'top';
+    inferredRowCount?: T | 'bottom' | 'infinite' | 'top';
+    /** difference between upper and lower bound of interval domain (to estimate approximation) */
+    approxRangeColCount?: T;
+    approxRangeRowCount?: T;
+}
 /**
  * Please note, that these measurement can be negative as there is no guarantee that the memory usage will increase
  * due to, e.g., garbage collection.
@@ -61,8 +87,11 @@ export interface SlicerStats {
     request: RParseRequestFromFile | RParseRequestFromText;
     input: SlicerStatsInput;
     dataflow: SlicerStatsDataflow;
+    dataFrameShape?: SlicerStatsDfShape;
     retrieveTimePerToken: TimePerToken<number>;
     normalizeTimePerToken: TimePerToken<number>;
     dataflowTimePerToken: TimePerToken<number>;
     totalCommonTimePerToken: TimePerToken<number>;
+    controlFlowTimePerToken?: TimePerToken<number>;
+    dataFrameShapeTimePerToken?: TimePerToken<number>;
 }

package/benchmark/stats/stats.js

@@ -1,6 +1,8 @@
 "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 = exports.CommonSlicerMeasurements = exports.OptionalSlicerMeasurements = exports.RequiredSlicerMeasurements = void 0;
+exports.RequiredSlicerMeasurements = ['initialize R session', 'retrieve AST from R code', 'normalize R AST', 'produce dataflow information', 'close R session', 'total'];
+exports.OptionalSlicerMeasurements = ['extract control flow graph', 'infer data frame shapes'];
+exports.CommonSlicerMeasurements = [...exports.RequiredSlicerMeasurements, ...exports.OptionalSlicerMeasurements];
 exports.PerSliceMeasurements = ['static slicing', 'reconstruct code', 'total'];
 //# sourceMappingURL=stats.js.map

package/benchmark/summarizer/data.d.ts

@@ -1,5 +1,6 @@
+import type { DataFrameOperationName } from '../../abstract-interpretation/data-frame/semantics';
 import type { SummarizedMeasurement } from '../../util/summarizer';
-import type { CommonSlicerMeasurements, PerSliceMeasurements, SlicerStats, SlicerStatsDataflow, SlicerStatsInput } from '../stats/stats';
+import type { CommonSlicerMeasurements, PerSliceMeasurements, SlicerStats, SlicerStatsDfShape, SlicerStatsDataflow, SlicerStatsInput } from '../stats/stats';
 export interface SliceSizeCollection {
     lines: number[];
     nonEmptyLines: number[];
@@ -21,7 +22,8 @@ export interface SliceSizeCollection {
  */
 export type SummarizedSlicerStats = {
     perSliceMeasurements: SummarizedPerSliceStats;
-} & Omit<SlicerStats, 'perSliceMeasurements'>;
+    dataFrameShape?: SummarizedDfShapeStats;
+} & Omit<SlicerStats, 'perSliceMeasurements' | 'dataFrameShape'>;
 export interface Reduction<T = number> {
     numberOfLines: T;
     numberOfLinesNoAutoSelection: T;
@@ -62,6 +64,8 @@ export interface UltimateSlicerStats {
     normalizeTimePerToken: TimePerToken;
     dataflowTimePerToken: TimePerToken;
     totalCommonTimePerToken: TimePerToken;
+    controlFlowTimePerToken?: TimePerToken;
+    dataFrameShapeTimePerToken?: TimePerToken;
     sliceTimePerToken: TimePerToken;
     reconstructTimePerToken: TimePerToken;
     totalPerSliceTimePerToken: TimePerToken;
@@ -74,4 +78,31 @@ export interface UltimateSlicerStats {
     reductionNoFluff: Reduction<SummarizedMeasurement>;
     input: SlicerStatsInput<SummarizedMeasurement>;
     dataflow: SlicerStatsDataflow<SummarizedMeasurement>;
+    dataFrameShape?: SummarizedDfShapeStats<SummarizedMeasurement>;
+}
+export interface SummarizedDfShapeStats<T = number> extends Omit<SlicerStatsDfShape<T>, 'perNodeStats'> {
+    numberOfEntriesPerNode: SummarizedMeasurement;
+    numberOfOperations: T;
+    numberOfTotalValues: T;
+    numberOfTotalTop: T;
+    numberOfTotalBottom: T;
+    inferredColNames: SummarizedMeasurement;
+    numberOfColNamesValues: T;
+    numberOfColNamesTop: T;
+    numberOfColNamesBottom: T;
+    inferredColCount: SummarizedMeasurement;
+    numberOfColCountExact: T;
+    numberOfColCountValues: T;
+    numberOfColCountTop: T;
+    numberOfColCountInfinite: T;
+    numberOfColCountBottom: T;
+    approxRangeColCount: SummarizedMeasurement;
+    inferredRowCount: SummarizedMeasurement;
+    numberOfRowCountExact: T;
+    numberOfRowCountValues: T;
+    numberOfRowCountTop: T;
+    numberOfRowCountInfinite: T;
+    numberOfRowCountBottom: T;
+    approxRangeRowCount: SummarizedMeasurement;
+    perOperationNumber: Map<DataFrameOperationName, T>;
 }

package/benchmark/summarizer/first-phase/input.js

@@ -28,7 +28,11 @@ async function processRunMeasurement(line, fileNum, lineNum, textOutputAppendPat
                 return [k, BigInt(v.slice(0, -1))];
             })),
             perSliceMeasurements: new Map(got.stats.perSliceMeasurements
-                .map(([k, v]) => mapPerSliceStats(k, v)))
+                .map(([k, v]) => mapPerSliceStats(k, v))),
+            dataFrameShape: got.stats.dataFrameShape !== undefined ? {
+                ...got.stats.dataFrameShape,
+                perNodeStats: new Map(got.stats.dataFrameShape.perNodeStats)
+            } : undefined
         }
     };
     const totalSlices = got.stats.perSliceMeasurements.size;

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

@@ -53,6 +53,7 @@ const retriever_1 = require("../../../r-bridge/retriever");
 const visitor_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/visitor");
 const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
 const arrays_1 = require("../../../util/collections/arrays");
+const semantics_1 = require("../../../abstract-interpretation/data-frame/semantics");
 const tempfile = (() => {
     let _tempfile = undefined;
     return () => {
@@ -250,9 +251,54 @@ async function summarizeSlicerStats(stats, report = () => {
                 normalizedTokensNoComments: (0, summarizer_1.summarizeMeasurement)(sliceSize.normalizedTokensNoComments),
                 dataflowNodes: (0, summarizer_1.summarizeMeasurement)(sliceSize.dataflowNodes)
             }
-        }
+        },
+        dataFrameShape: stats.dataFrameShape ? summarizeDfShapeStats(stats.dataFrameShape) : undefined
+    };
+}
+function summarizeDfShapeStats({ perNodeStats, ...stats }) {
+    const nodeStats = perNodeStats.values().toArray();
+    const isTop = (value) => value === 'top';
+    const isInfinite = (value) => value === 'infinite';
+    const isBottom = (value) => value === 'bottom';
+    const isValue = (value) => value !== undefined && !isTop(value) && !isInfinite(value) && !isBottom(value);
+    return {
+        ...stats,
+        numberOfEntriesPerNode: (0, summarizer_1.summarizeMeasurement)(nodeStats.map(s => s.numberOfEntries)),
+        numberOfOperations: (0, arrays_1.arraySum)(nodeStats.map(s => s.mappedOperations?.length).filter(assert_1.isNotUndefined)),
+        numberOfTotalValues: nodeStats.filter(s => isValue(s.inferredColNames) && isValue(s.inferredColCount) && isValue(s.inferredRowCount)).length,
+        numberOfTotalTop: nodeStats.filter(s => isTop(s.inferredColNames) && isTop(s.inferredColCount) && isTop(s.inferredRowCount)).length,
+        numberOfTotalBottom: nodeStats.filter(s => s.inferredColNames === 0 && isBottom(s.inferredColCount) && isBottom(s.inferredRowCount)).length,
+        inferredColNames: (0, summarizer_1.summarizeMeasurement)(nodeStats.map(s => s.inferredColNames).filter(isValue)),
+        numberOfColNamesValues: nodeStats.map(s => s.inferredColNames).filter(isValue).length,
+        numberOfColNamesTop: nodeStats.map(s => s.inferredColNames).filter(isTop).length,
+        numberOfColNamesBottom: nodeStats.map(s => s.inferredColNames).filter(number => number === 0).length,
+        inferredColCount: (0, summarizer_1.summarizeMeasurement)(nodeStats.map(s => s.inferredColCount).filter(isValue)),
+        numberOfColCountExact: nodeStats.map(s => s.approxRangeColCount).filter(range => range === 0).length,
+        numberOfColCountValues: nodeStats.map(s => s.inferredColCount).filter(isValue).length,
+        numberOfColCountTop: nodeStats.map(s => s.inferredColCount).filter(isTop).length,
+        numberOfColCountInfinite: nodeStats.map(s => s.inferredColCount).filter(isInfinite).length,
+        numberOfColCountBottom: nodeStats.map(s => s.inferredColCount).filter(isBottom).length,
+        approxRangeColCount: (0, summarizer_1.summarizeMeasurement)(nodeStats.map(s => s.approxRangeColCount).filter(assert_1.isNotUndefined).filter(isFinite)),
+        inferredRowCount: (0, summarizer_1.summarizeMeasurement)(nodeStats.map(s => s.inferredRowCount).filter(isValue)),
+        numberOfRowCountExact: nodeStats.map(s => s.approxRangeRowCount).filter(range => range === 0).length,
+        numberOfRowCountValues: nodeStats.map(s => s.inferredRowCount).filter(isValue).length,
+        numberOfRowCountTop: nodeStats.map(s => s.inferredRowCount).filter(isTop).length,
+        numberOfRowCountInfinite: nodeStats.map(s => s.inferredRowCount).filter(isInfinite).length,
+        numberOfRowCountBottom: nodeStats.map(s => s.inferredRowCount).filter(isBottom).length,
+        approxRangeRowCount: (0, summarizer_1.summarizeMeasurement)(nodeStats.map(s => s.approxRangeRowCount).filter(assert_1.isNotUndefined).filter(isFinite)),
+        perOperationNumber: summarizePerOperationStats(nodeStats),
     };
 }
+function summarizePerOperationStats(nodeStats) {
+    const perOperationNumber = new Map(semantics_1.DataFrameOperationNames.map(name => [name, 0]));
+    for (const stat of nodeStats) {
+        for (const operation of stat.mappedOperations ?? []) {
+            const value = perOperationNumber.get(operation) ?? 0;
+            perOperationNumber.set(operation, value + 1);
+        }
+    }
+    return perOperationNumber;
+}
 function summarizeSummarizedMeasurement(data) {
     data = data.filter(assert_1.isNotUndefined);
     const min = Math.min(...data.map(d => d.min).filter(assert_1.isNotUndefined));

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

@@ -11,7 +11,7 @@ function writeGraphOutput(ultimate, 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') {
+            if (point === 'close R session' || point === 'initialize R session' || !measurement?.mean || !measurement?.std) {
                 continue;
             }
             const pointName = point === 'total' ? `total ${name}` : point;