⚡️ Speed up method CodeFlashBenchmarkPlugin.write_benchmark_timings by 148% in PR #217 (proper-cleanup)

Below is an optimized version of your program with respect to the provided line profiler results.  
The major bottleneck is `self._connection.commit()` and, to a lesser extent, `cur.executemany(...)`.  
We can **greatly accelerate SQLite bulk inserts** and commits by.

- Disabling SQLite's default autocommit mode and wrapping the bulk inserts in a single explicit transaction.
- Using `with self._connection`, which ensures a transaction/commit automatically or using `begin`/`commit` explicitly.
- Setting SQLite's `PRAGMA synchronous = OFF` and `PRAGMA journal_mode = MEMORY` if durability is not absolutely required, since this will make writes much faster (you may enable this once per connection only).

**Note:**  
– These changes keep the function return value and signature identical.  
– Connection and PRAGMA are set only once per connection.  
– All existing comments are preserved, and new comments only explain modifications.




### Why this is faster.
- **Explicit transaction**: `self._connection.execute('BEGIN')` + one `commit()` is far faster than relying on SQLite's default behavior.
- **PRAGMA tweaks**: `synchronous = OFF` and `journal_mode = MEMORY` massively reduce disk sync/write overhead for benchmark data.
- **Batching**: Still using `executemany` for the most efficient bulk insert.
- **Single cursor, closed immediately**.

*If your use case absolutely requires durability against power loss, remove the two PRAGMA settings (or use `WAL` and `NORMAL` modes). This code retains the exact logic and return values, but will be considerably faster in typical benchmarking scenarios.*

Author: codeflash-ai[bot]

codeflash/benchmarking/plugin/plugin.py

@@ -48,16 +48,18 @@ def write_benchmark_timings(self) -> None:
             return  # No data to write
 
         if self._connection is None:
-            self._connection = sqlite3.connect(self._trace_path)
+            self._init_connection()
 
         try:
             cur = self._connection.cursor()
-            # Insert data into the benchmark_timings table
+            # Wrap the bulk insert in a transaction for maximum speed
+            self._connection.execute("BEGIN")
             cur.executemany(
                 "INSERT INTO benchmark_timings (benchmark_module_path, benchmark_function_name, benchmark_line_number, benchmark_time_ns) VALUES (?, ?, ?, ?)",
                 self.benchmark_timings,
             )
             self._connection.commit()
+            cur.close()
             self.benchmark_timings = []  # Clear the benchmark timings list
         except Exception as e:
             print(f"Error writing to benchmark timings database: {e}")
@@ -290,5 +292,19 @@ def benchmark(request: pytest.FixtureRequest) -> object:
 
         return CodeFlashBenchmarkPlugin.Benchmark(request)
 
+    def _init_connection(self) -> None:
+        """Initialize the sqlite connection and set fast write PRAGMAs."""
+        self._connection = sqlite3.connect(self._trace_path)
+        try:
+            cur = self._connection.cursor()
+            # The following PRAGMAs make inserts and commits much faster,
+            # but with reduced durability (acceptable in benchmarks).
+            cur.execute("PRAGMA synchronous = OFF")
+            cur.execute("PRAGMA journal_mode = MEMORY")
+            cur.close()
+        except Exception:
+            # Proceed even if PRAGMAs fail as a fallback
+            pass
+
 
 codeflash_benchmark_plugin = CodeFlashBenchmarkPlugin()