perf instrumentation as well

Author: misrasaurabh1

code_to_optimize_js/codeflash-jest-helper.js

@@ -225,8 +225,9 @@ function recordResult(funcName, args, returnValue, error, durationNs) {
 /**
  * Capture a function call with full behavior tracking.
  *
- * This is the main API for instrumenting function calls.
- * It captures inputs, outputs, errors, and timing for every call.
+ * This is the main API for instrumenting function calls for BEHAVIOR verification.
+ * It captures inputs (after call, to detect mutations), outputs, errors, and timing.
+ * Results are written to SQLite for comparison between original and optimized code.
  *
  * @param {string} funcName - Name of the function being tested
  * @param {Function} fn - The function to call
@@ -251,6 +252,7 @@ function capture(funcName, fn, ...args) {
                 (resolved) => {
                     const endTime = performance.now();
                     const durationNs = (endTime - startTime) * 1_000_000;
+                    // Note: args is captured AFTER the call to detect mutations
                     recordResult(funcName, args, resolved, null, durationNs);
                     return resolved;
                 },
@@ -268,12 +270,83 @@ function capture(funcName, fn, ...args) {
 
     const endTime = performance.now();
     const durationNs = (endTime - startTime) * 1_000_000;
+    // Note: args is captured AFTER the call to detect mutations (same as Python)
     recordResult(funcName, args, returnValue, error, durationNs);
 
     if (error) throw error;
     return returnValue;
 }
 
+/**
+ * Capture a function call for PERFORMANCE benchmarking only.
+ *
+ * This is a lightweight instrumentation that only measures timing.
+ * It prints start/end tags to stdout (no SQLite writes, no serialization overhead).
+ * Used when we've already verified behavior and just need accurate timing.
+ *
+ * Output format matches Python's codeflash_performance wrapper:
+ * Start: !$######test_module:test_class.test_name:func_name:loop_index:invocation_id######$!
+ * End:   !######test_module:test_class.test_name:func_name:loop_index:invocation_id:duration_ns######!
+ *
+ * @param {string} funcName - Name of the function being tested
+ * @param {Function} fn - The function to call
+ * @param {...any} args - Arguments to pass to the function
+ * @returns {any} - The function's return value
+ * @throws {Error} - Re-throws any error from the function
+ */
+function capturePerf(funcName, fn, ...args) {
+    const invocationId = `${lineId}_${invocationCounter}`;
+    invocationCounter++;
+
+    // Get test context
+    const testModulePath = TEST_MODULE || currentTestName || 'unknown';
+    const testClassName = '';  // Jest doesn't use classes like Python
+
+    // Format: test_module:test_class.test_name:func_name:loop_index:invocation_id
+    const testStdoutTag = `${testModulePath}:${testClassName}${currentTestName}:${funcName}:${LOOP_INDEX}:${invocationId}`;
+
+    // Print start tag
+    console.log(`!$######${testStdoutTag}######$!`);
+
+    const startTime = performance.now();
+    let returnValue;
+    let error = null;
+
+    try {
+        returnValue = fn(...args);
+
+        // Handle promises (async functions)
+        if (returnValue instanceof Promise) {
+            return returnValue.then(
+                (resolved) => {
+                    const endTime = performance.now();
+                    const durationNs = Math.round((endTime - startTime) * 1_000_000);
+                    // Print end tag with timing
+                    console.log(`!######${testStdoutTag}:${durationNs}######!`);
+                    return resolved;
+                },
+                (err) => {
+                    const endTime = performance.now();
+                    const durationNs = Math.round((endTime - startTime) * 1_000_000);
+                    // Print end tag with timing even on error
+                    console.log(`!######${testStdoutTag}:${durationNs}######!`);
+                    throw err;
+                }
+            );
+        }
+    } catch (e) {
+        error = e;
+    }
+
+    const endTime = performance.now();
+    const durationNs = Math.round((endTime - startTime) * 1_000_000);
+    // Print end tag with timing
+    console.log(`!######${testStdoutTag}:${durationNs}######!`);
+
+    if (error) throw error;
+    return returnValue;
+}
+
 /**
  * Capture multiple invocations for benchmarking.
  *
@@ -372,7 +445,8 @@ if (typeof afterAll !== 'undefined') {
 
 // Export public API
 module.exports = {
-    capture,
+    capture,           // Behavior verification (writes to SQLite)
+    capturePerf,       // Performance benchmarking (prints to stdout only)
     captureMultiple,
     writeResults,
     clearResults,

code_to_optimize_js/test_better_sqlite.js

@@ -0,0 +1,13 @@
+try {
+    const Database = require('better-sqlite3');
+    console.log('better-sqlite3 loaded successfully');
+    const db = new Database('/tmp/test_better_sqlite.db');
+    db.exec('CREATE TABLE test (id INTEGER)');
+    db.exec('INSERT INTO test VALUES (1)');
+    const row = db.prepare('SELECT * FROM test').get();
+    console.log('Row:', row);
+    db.close();
+    console.log('Database test passed');
+} catch (e) {
+    console.error('Error:', e.message);
+}

code_to_optimize_js/test_sqlite_helper.js

@@ -0,0 +1,22 @@
+const codeflash = require('./codeflash-jest-helper');
+const { reverseString } = require('./string_utils');
+
+// Manually set test context
+process.env.CODEFLASH_OUTPUT_FILE = '/tmp/test_codeflash.sqlite';
+process.env.CODEFLASH_LOOP_INDEX = '1';
+process.env.CODEFLASH_TEST_MODULE = 'test_module';
+
+// Mock beforeEach/afterAll for non-Jest environment
+global.expect = { getState: () => ({ currentTestName: 'manual_test' }) };
+
+// Initialize database
+codeflash.initDatabase();
+codeflash.setTestName('manual_test');
+
+// Capture a function call
+const result = codeflash.capture('reverseString', reverseString, 'hello');
+console.log('Result:', result);
+
+// Write results
+codeflash.writeResults();
+console.log('Done');