Merge pull request #53 from Chessray/eb/ffp-poc

Eb/ffp poc

Author: adamretter

jmh_full_get_java21.json

@@ -0,0 +1,19 @@
+{
+    "benchmark": "GetJNIBenchmark",
+    "jvmargs": ["Xmx4G", "XX:ErrorFile=./results/hs_err_pid%p.log", "XX:+HeapDumpOnOutOfMemoryError", "-enable-preview"],
+    "params": {
+        "valueSize": [10, 50, 512, 1024, 4096, 8192, 16384, 32768, 65536],
+        "cacheMB": [1],
+        "checksum": ["none", "copyout"]
+    },
+    "options": {
+        "batchsize": 1,
+        "warmupiterations": 20,
+        "warmuptime": "50ms",
+        "iterations": 50,
+        "time": "500ms"
+    },
+    "result.path": "./results",
+    "java.library.path": "target/jni-benchmarks-1.0.1-SNAPSHOT-application/jni-benchmarks-1.0.1-SNAPSHOT/lib",
+    "jar": "target/jni-benchmarks-1.0.1-SNAPSHOT-benchmarks.nar"
+}

jmh_full_put_java21.json

@@ -0,0 +1,19 @@
+{
+    "benchmark": "PutJNIBenchmark",
+    "jvmargs": ["Xmx4G", "XX:ErrorFile=./results/hs_err_pid%p.log", "XX:+HeapDumpOnOutOfMemoryError", "-enable-preview"],
+    "params": {
+        "valueSize": [10, 50, 512, 1024, 4096, 8192, 16384, 32768, 65536],
+        "cacheMB": [1],
+        "checksum": ["none", "copyin"]
+    },
+    "options": {
+        "batchsize": 1,
+        "warmupiterations": 20,
+        "warmuptime": "50ms",
+        "iterations": 50,
+        "time": "500ms"
+    },
+    "result.path": "./results",
+    "java.library.path": "target/jni-benchmarks-1.0.1-SNAPSHOT-application/jni-benchmarks-1.0.1-SNAPSHOT/lib",
+    "jar": "target/jni-benchmarks-1.0.1-SNAPSHOT-benchmarks.nar"
+}

jmh_plot.json

@@ -5,15 +5,17 @@
                 "name": "valueSize",
                 "min": 1024
             },
-            "label": "allbig"
+            "label": "allbig",
+            "valueSizeTitle": ">= 1024"
         },
         {
             "xaxisparam": {
                 "name": "valueSize",
                 "min": 1,
                 "max": 4096
             },
-            "label": "allsmall"
+            "label": "allsmall",
+            "valueSizeTitle": "<= 4096"
             # defaults to include_patterns of all matching
         },
         {
@@ -23,15 +25,17 @@
                 "max": 4096
             },
             "exclude_patterns": ["Pooled"],
-            "label": "nopoolsmall"
+            "label": "nopoolsmall",
+            "valueSizeTitle": "<= 4096"
         },
         {
             "xaxisparam": {
                 "name": "valueSize",
                 "min": 1024
             },
             "exclude_patterns": ["Pooled"],
-            "label": "nopoolbig"
+            "label": "nopoolbig",
+            "valueSizeTitle": ">= 1024"
         },
         {
             "xaxisparam": {
@@ -84,4 +88,4 @@
         }
     ],
     "result.path": "./analysis/testplots"
-}
+}

jmh_small_get_java21.json

@@ -0,0 +1,19 @@
+{
+    "benchmark": "GetJNIBenchmark",
+    "jvmargs": ["Xmx4G", "XX:ErrorFile=./results/hs_err_pid%p.log", "XX:+HeapDumpOnOutOfMemoryError", "-enable-preview"],
+    "params": {
+        "valueSize": [10, 50, 512, 1024, 4096, 8192, 16384, 32768, 65536],
+        "cacheMB": [1],
+        "checksum": ["none", "copyout"]
+    },
+    "options": {
+        "batchsize": 1,
+        "warmupiterations": 10,
+        "warmuptime": "20ms",
+        "iterations": 20,
+        "time": "200ms"
+    },
+    "result.path": "./results",
+    "java.library.path": "target/jni-benchmarks-1.0.1-SNAPSHOT-application/jni-benchmarks-1.0.1-SNAPSHOT/lib",
+    "jar": "target/jni-benchmarks-1.0.1-SNAPSHOT-benchmarks.nar"
+}

jmh_small_put_java21.json

@@ -0,0 +1,19 @@
+{
+    "benchmark": "PutJNIBenchmark",
+    "jvmargs": ["Xmx4G", "XX:ErrorFile=./results/hs_err_pid%p.log", "XX:+HeapDumpOnOutOfMemoryError", "-enable-preview"],
+    "params": {
+        "valueSize": [10, 50, 512, 1024, 4096, 8192, 16384, 32768, 65536],
+        "cacheMB": [1],
+        "checksum": ["none", "copyin"]
+    },
+    "options": {
+        "batchsize": 1,
+        "warmupiterations": 5,
+        "warmuptime": "20ms",
+        "iterations": 10,
+        "time": "100ms"
+    },
+    "result.path": "./results",
+    "java.library.path": "target/jni-benchmarks-1.0.1-SNAPSHOT-application/jni-benchmarks-1.0.1-SNAPSHOT/lib",
+    "jar": "target/jni-benchmarks-1.0.1-SNAPSHOT-benchmarks.nar"
+}

jmh_tiny_get_java21.json

@@ -0,0 +1,19 @@
+{
+    "benchmark": "GetJNIBenchmark",
+    "jvmargs": ["Xmx4G", "XX:ErrorFile=./results/hs_err_pid%p.log", "XX:+HeapDumpOnOutOfMemoryError", "-enable-preview"],
+    "params": {
+        "valueSize": [50, 1024, 4096, 16384],
+        "cacheMB": [1],
+        "checksum": ["none", "copyout"]
+    },
+    "options": {
+        "batchsize": 1,
+        "warmupiterations": 5,
+        "warmuptime": "10ms",
+        "iterations": 5,
+        "time": "50ms"
+    },
+    "result.path": "./results",
+    "java.library.path": "target/jni-benchmarks-1.0.1-SNAPSHOT-application/jni-benchmarks-1.0.1-SNAPSHOT/lib",
+    "jar": "target/jni-benchmarks-1.0.1-SNAPSHOT-benchmarks.nar"
+}

jmh_tiny_put_java21.json

@@ -0,0 +1,19 @@
+{
+    "benchmark": "PutJNIBenchmark",
+    "jvmargs": ["Xmx4G", "XX:ErrorFile=./results/hs_err_pid%p.log", "XX:+HeapDumpOnOutOfMemoryError", "-enable-preview"],
+    "params": {
+        "valueSize": [50, 1024, 4096, 16384],
+        "cacheMB": [1],
+        "checksum": ["none", "copyin"]
+    },
+    "options": {
+        "batchsize": 1,
+        "warmupiterations": 5,
+        "warmuptime": "10ms",
+        "iterations": 5,
+        "time": "50ms"
+    },
+    "result.path": "./results",
+    "java.library.path": "target/jni-benchmarks-1.0.1-SNAPSHOT-application/jni-benchmarks-1.0.1-SNAPSHOT/lib",
+    "jar": "target/jni-benchmarks-1.0.1-SNAPSHOT-benchmarks.nar"
+}

jmhplot.py

@@ -35,6 +35,7 @@
 
 import numpy as np
 import matplotlib.pyplot as plt
+import matplotlib.ticker as ticker
 import pandas as pd
 from pandas.core.frame import DataFrame
 import re
@@ -193,11 +194,11 @@ def tuple_of_secondary_keys(params: BMParams) -> Tuple:
     return tuple(secondaryKeys)
 
 
-def plot_all_results(params: BMParams, resultSets: ResultSets, path, include_benchmarks: str, exclude_benchmarks: str, label: str) -> None:
+def plot_all_results(params: BMParams, xaxisparam:Dict, result_sets: ResultSets, path, include_benchmarks: str, exclude_benchmarks: str, label: str, value_size_title: str, system_info: str) -> None:
     indexKeys = tuple_of_secondary_keys(params)
-    for indexTuple, resultSet in resultSets.items():
-        plot_result_set(indexKeys, indexTuple, resultSet,
-                        path, include_benchmarks, exclude_benchmarks, label)
+    for indexTuple, resultSet in result_sets.items():
+        plot_result_set(xaxisparam, indexKeys, indexTuple, resultSet,
+                        path, include_benchmarks, exclude_benchmarks, label, value_size_title, system_info)
 
 
 def plot_result_axis_errorbars(ax, resultSet: ResultSet) -> None:
@@ -256,7 +257,7 @@ def plot_result_axis_bars(ax, resultSet: ResultSet) -> None:
         bmIndex = bmIndex + 1
 
 
-def plot_result_set(indexKeys: Tuple, indexTuple: Tuple, resultSet: ResultSet, path: pathlib.Path, include_benchmarks: str, exclude_benchmarks: str, label: str):
+def plot_result_set(xaxisparam:Dict, indexKeys: Tuple, indexTuple: Tuple, resultSet: ResultSet, path: pathlib.Path, include_benchmarks: str, exclude_benchmarks: str, label: str, value_size_title: str, system_info: str):
     # Determine how many colors we need
     num_benchmarks = len(resultSet)
 
@@ -273,18 +274,24 @@ def plot_result_set(indexKeys: Tuple, indexTuple: Tuple, resultSet: ResultSet, p
 
     plot_result_axis_bars(ax, resultSet)
 
-    plt.suptitle("x86_64 - Xeon E5-1650 v3 @ 3.50GHz - 128GB ECC RAM - Ubuntu 24.04.3 LTS - Kernel: 6.14.0-36-generic")
-    plt.title(
-        f'{str(indexKeys)}={str(indexTuple)} include={include_benchmarks} exclude={exclude_benchmarks}')
-    plt.xlabel("# Operations")
+    # Ensure more marks on the x-axis for log scale
+    ax.xaxis.set_major_locator(ticker.LogLocator(base=10.0, numticks=15))
+    ax.xaxis.set_minor_locator(ticker.LogLocator(base=10.0, subs='auto', numticks=15))
+    ax.xaxis.set_major_formatter(ticker.ScalarFormatter())
+    ax.xaxis.set_minor_formatter(ticker.NullFormatter())
+
+    plt.suptitle(system_info)
+    title = f'{str(indexKeys)}={str(indexTuple)} include={include_benchmarks} exclude={exclude_benchmarks} Value Size="{value_size_title}"'
+    plt.title(title)
+    plt.xlabel(extract_parameter_name(xaxisparam))
     plt.ylabel("t (ns)")
     plt.legend(loc='upper left', bbox_to_anchor=(1, 1))
     plt.grid(visible='True', which='both')
 
     name = f'fig_{"_".join([str(t) for t in indexTuple])}_{label}.png'
 
     if path.is_file():
-        path = path.parent()
+        path = path.parent
     fig.savefig(path.joinpath(name), bbox_inches='tight')
 
 
@@ -322,7 +329,7 @@ def filter_for_benchmarks(dataframe: DataFrame, include_benchmarks, exclude_benc
 
 def filter_for_range(dataframe: DataFrame, xaxisparam: Dict) -> DataFrame:
 
-    param_name = required('name', xaxisparam)
+    param_name = extract_parameter_name(xaxisparam)
     xmin = optional('min', xaxisparam, lambda x: int(x))
     xmax = optional('max', xaxisparam, lambda x: int(x))
     if xmax is None and xmin is None:
@@ -340,6 +347,14 @@ def filter_for_range(dataframe: DataFrame, xaxisparam: Dict) -> DataFrame:
         lambda x: int(x) >= xmin and int(x) <= xmax)]
 
 
+def extract_parameter_name(xaxisparam):
+    return required('name', xaxisparam)
+
+
+def default_if_none(optional_string, default_value: str) -> str:
+    return default_value if optional_string is None else optional_string
+
+
 def process_some_plots(path: pathlib.Path, plot: Dict) -> None:
 
     xaxisparam = required('xaxisparam', plot)
@@ -348,6 +363,26 @@ def process_some_plots(path: pathlib.Path, plot: Dict) -> None:
     include_benchmarks = optional('include_patterns', plot)
     exclude_benchmarks = optional('exclude_patterns', plot)
     label = required('label', plot)
+    value_size_title = default_if_none(optional('valueSizeTitle', plot), "All")
+
+    # Check for system_info.json in the path
+    system_info = None
+    system_info_file = None
+    if path.is_dir():
+        system_info_file = path.joinpath('system_info.json')
+    if path.is_file():
+        system_info_file = path.parent.joinpath('system_info.json')
+
+    if system_info_file and system_info_file.exists():
+        try:
+            with system_info_file.open(mode='r', encoding='UTF-8') as f:
+                info_json = json.load(f)
+                system_info = info_json.get('system_info')
+        except Exception:
+            pass
+
+    if system_info is None:
+        system_info = "System Info unavailable"
 
     dataframe = normalize_data_frame_from_path(path)
     if len(dataframe) == 0:
@@ -368,8 +403,8 @@ def process_some_plots(path: pathlib.Path, plot: Dict) -> None:
     params: BMParams = split_params(
         extract_params(dataframe), primary_param_name)
     resultSets = extract_results_per_param(dataframe, params)
-    plot_all_results(params, resultSets, path,
-                     include_benchmarks, exclude_benchmarks, label)
+    plot_all_results(params, xaxisparam, resultSets, path,
+                     include_benchmarks, exclude_benchmarks, label, value_size_title, system_info)
 
 
 def process_benchmarks(config: Dict) -> None:

jmhrun.py

@@ -32,6 +32,7 @@
 import pathlib
 import json
 import subprocess
+import platform
 from typing import Dict
 
 
@@ -112,6 +113,81 @@ def output_options(config: Dict) -> list:
     return ['-rff', str(path.joinpath(pathlib.Path(f'jmh_{const_datetime_str}.csv')))]
 
 
+def get_system_info() -> str:
+    try:
+        arch = platform.machine()
+        system = platform.system()
+        kernel = platform.release()
+
+        cpu_model = ""
+        ram_info = ""
+        os_info = ""
+        java_info = ""
+
+        try:
+            java_version_out = subprocess.check_output(['java', '-version'], stderr=subprocess.STDOUT).decode().strip()
+            # The first line usually contains the version information
+            java_info = java_version_out.splitlines()[0]
+        except Exception:
+            java_info = "Unknown Java"
+
+        if system == "Darwin":
+            try:
+                cpu_model = subprocess.check_output(['sysctl', '-n', 'machdep.cpu.brand_string']).decode().strip()
+            except Exception:
+                cpu_model = platform.processor()
+
+            try:
+                mem_bytes = int(subprocess.check_output(['sysctl', '-n', 'hw.memsize']).decode().strip())
+                ram_info = f"{mem_bytes // (1024**3)}GB RAM"
+            except Exception:
+                ram_info = "Unknown RAM"
+
+            os_info = f"macOS {platform.mac_ver()[0]}"
+
+        elif system == "Linux":
+            try:
+                with open("/proc/cpuinfo", "r") as f:
+                    for line in f:
+                        if "model name" in line:
+                            cpu_model = line.split(":")[1].strip()
+                            break
+            except Exception:
+                cpu_model = platform.processor()
+
+            try:
+                with open("/proc/meminfo", "r") as f:
+                    for line in f:
+                        if "MemTotal" in line:
+                            mem_kb = int(line.split(":")[1].strip().split()[0])
+                            ram_info = f"{mem_kb // (1024**2)}GB RAM"
+                            break
+            except Exception:
+                ram_info = "Unknown RAM"
+
+            try:
+                import lsb_release
+                os_info = lsb_release.get_distro_information()['DESCRIPTION']
+            except Exception:
+                try:
+                    with open("/etc/os-release", "r") as f:
+                        for line in f:
+                            if line.startswith("PRETTY_NAME="):
+                                os_info = line.split("=")[1].strip().strip('"')
+                                break
+                except Exception:
+                    os_info = f"Linux {platform.release()}"
+
+        else:
+            cpu_model = platform.processor()
+            os_info = f"{system} {platform.release()}"
+
+        return f"{arch} - {cpu_model} - {ram_info} - {os_info} - Kernel: {kernel} - {java_info}"
+
+    except Exception as e:
+        return f"Unknown System - {str(e)}"
+
+
 def build_jmh_command(config: Dict) -> list:
 
     cmd = ["java"]
@@ -192,6 +268,11 @@ def log_jmh_session(cmd: list, config: Dict, config_file: str):
         log.writelines(line + '\n' for line in
                        ['```', '#### Command', 'The java command executed to run the tests', '```', ' '.join(cmd), '```'])
 
+    # Save system info
+    system_info_file = output_dir_path(config).joinpath('system_info.json')
+    with system_info_file.open(mode='w', encoding='UTF-8') as f:
+        json.dump({"system_info": get_system_info()}, f, indent=4)
+
 
 def exec_jmh_cmd(cmd: list, help_requested):
     cmd_str = ' '.join(cmd)