update benchmark

Signed-off-by: Gregor Zeitlinger <[email protected]>

Author: zeitlinger

.mise/tasks/run_benchmarks.py

@@ -82,6 +82,31 @@ def extract_first_table(jmh_output: str) -> str:
     return table
 
 
+def filter_table_for_class(table: str, class_name: str) -> Optional[str]:
+    """
+    Return a table string that contains only the header and the lines belonging to `class_name`.
+    If no matching lines are found, return None.
+    """
+    lines = table.splitlines()
+    # find header line index (starts with 'Benchmark' and contains 'Mode')
+    header_idx = None
+    for i, ln in enumerate(lines):
+        if ln.strip().startswith('Benchmark') and 'Mode' in ln:
+            header_idx = i
+            break
+    header = lines[header_idx] if header_idx is not None else 'Benchmark                                     Mode  Cnt      Score     Error  Units'
+
+    matched = []
+    pattern = re.compile(r'^\s*' + re.escape(class_name) + r'\.')
+    for ln in lines[header_idx + 1 if header_idx is not None else 0:]:
+        if 'thrpt' in ln and pattern.search(ln):
+            matched.append(ln)
+
+    if not matched:
+        return None
+    return header + '\n' + '\n'.join(matched)
+
+
 def update_pre_blocks_under_module(module: str, table: str) -> List[str]:
     # Find files under module and update any <pre>...</pre> block that contains 'thrpt'
     updated_files = []
@@ -100,14 +125,24 @@ def update_pre_blocks_under_module(module: str, table: str) -> List[str]:
         original = content
         new_content = content
 
+        # Determine the class name from the filename (e.g. TextFormatUtilBenchmark.java -> TextFormatUtilBenchmark)
+        base = os.path.basename(path)
+        class_name = os.path.splitext(base)[0]
+
+        # Build a filtered table for this class; if no matching lines, skip updating this file
+        filtered_table = filter_table_for_class(table, class_name)
+        if filtered_table is None:
+            # nothing to update for this class
+            continue
+
         # Regex to find any line-starting Javadoc prefix like " * " before <pre>
         # This will match patterns like: " * <pre>... </pre>" and capture the prefix (e.g. " * ")
         pattern = re.compile(r'(?m)^(?P<prefix>[ \t]*\*[ \t]*)<pre>[\s\S]*?</pre>')
 
         def repl(m: re.Match) -> str:
             prefix = m.group('prefix')
             # Build the new block with the same prefix on each line
-            lines = table.splitlines()
+            lines = filtered_table.splitlines()
             replaced = prefix + '<pre>\n'
             for ln in lines:
                 replaced += prefix + ln.rstrip() + '\n'

.mise/tasks/test_run_benchmarks.py

@@ -0,0 +1,90 @@
+import os
+import re
+import sys
+import tempfile
+import unittest
+
+# Ensure the tasks directory is importable when running the test directly
+here = os.path.dirname(__file__)
+if here not in sys.path:
+    sys.path.insert(0, here)
+
+from run_benchmarks import update_pre_blocks_under_module
+
+
+class TestRunBenchmarksFiltering(unittest.TestCase):
+    def setUp(self):
+        # sample JMH table with mixed-class lines
+        self.table = (
+            'Benchmark                                             Mode  Cnt       Score   Error  Units\n'
+            'CounterBenchmark.codahaleIncNoLabels                 thrpt        57881.585          ops/s\n'
+            'HistogramBenchmark.prometheusNative                  thrpt         2385.134          ops/s\n'
+            'TextFormatUtilBenchmark.prometheusWriteToNull        thrpt       885331.328          ops/s\n'
+            'CounterBenchmark.prometheusInc                       thrpt        54090.469          ops/s\n'
+        )
+
+        # create temp dir to act as module path
+        self.tmpdir = tempfile.TemporaryDirectory()
+        self.module_path = self.tmpdir.name
+
+        # Create three files with a javadoc <pre> block that contains mixed results
+        self.files = {}
+        javadoc_pre = (
+            '/**\n'
+            ' * Example javadoc\n'
+            ' * <pre>\n'
+            ' * Benchmark                                             Mode  Cnt       Score   Error  Units\n'
+            ' * CounterBenchmark.codahaleIncNoLabels                 thrpt        57881.585          ops/s\n'
+            ' * HistogramBenchmark.prometheusNative                  thrpt         2385.134          ops/s\n'
+            ' * TextFormatUtilBenchmark.prometheusWriteToNull        thrpt       885331.328          ops/s\n'
+            ' * CounterBenchmark.prometheusInc                       thrpt        54090.469          ops/s\n'
+            ' * </pre>\n'
+            ' */\n'
+        )
+
+        for cls in ('CounterBenchmark', 'HistogramBenchmark', 'TextFormatUtilBenchmark'):
+            fname = os.path.join(self.module_path, f'{cls}.java')
+            with open(fname, 'w', encoding='utf-8') as f:
+                f.write(javadoc_pre)
+                f.write(f'public class {cls} {{}}\n')
+            self.files[cls] = fname
+
+    def tearDown(self):
+        self.tmpdir.cleanup()
+
+    def _read_pre_contents(self, path):
+        with open(path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        m = re.search(r'<pre>\n([\s\S]*?)</pre>', content)
+        return m.group(1) if m else ''
+
+    def test_update_only_inserts_matching_class_lines(self):
+        updated = update_pre_blocks_under_module(self.module_path, self.table)
+        # All three files should be updated
+        self.assertEqual(set(os.path.basename(p) for p in updated),
+                         {os.path.basename(self.files['CounterBenchmark']),
+                          os.path.basename(self.files['HistogramBenchmark']),
+                          os.path.basename(self.files['TextFormatUtilBenchmark'])})
+
+        # Verify CounterBenchmark file contains only CounterBenchmark lines
+        cb_pre = self._read_pre_contents(self.files['CounterBenchmark'])
+        self.assertIn('CounterBenchmark.codahaleIncNoLabels', cb_pre)
+        self.assertIn('CounterBenchmark.prometheusInc', cb_pre)
+        self.assertNotIn('HistogramBenchmark.prometheusNative', cb_pre)
+        self.assertNotIn('TextFormatUtilBenchmark.prometheusWriteToNull', cb_pre)
+
+        # Verify HistogramBenchmark contains only its line
+        hb_pre = self._read_pre_contents(self.files['HistogramBenchmark'])
+        self.assertIn('HistogramBenchmark.prometheusNative', hb_pre)
+        self.assertNotIn('CounterBenchmark.codahaleIncNoLabels', hb_pre)
+        self.assertNotIn('TextFormatUtilBenchmark.prometheusWriteToNull', hb_pre)
+
+        # Verify TextFormatUtilBenchmark contains only its line
+        tf_pre = self._read_pre_contents(self.files['TextFormatUtilBenchmark'])
+        self.assertIn('TextFormatUtilBenchmark.prometheusWriteToNull', tf_pre)
+        self.assertNotIn('CounterBenchmark.prometheusInc', tf_pre)
+        self.assertNotIn('HistogramBenchmark.prometheusNative', tf_pre)
+
+
+if __name__ == '__main__':
+    unittest.main()