Minor additions to plotting

Signed-off-by: Effi-S <effi.szt@gmail.com>

Author: Effi-S

cmd/benchmarking/plotly_plot_node.py

@@ -7,7 +7,8 @@
 st.set_page_config(
     layout="wide", page_icon=":chart_with_upwards_trend:", page_title="TPS Degradation")
 
-# Generic benchmark line parser
+DEFAULT_BENCH_DIR = "bench6"
+
 SERVICE_RE = re.compile(
     r'^(?P<bench>\S+)-(?P<workers>\d+)\s+'
     r'(?P<iterations>\d+)\s+'
@@ -19,15 +20,6 @@
     r'(?P<value>\d+)\s+ns/op\s+\((?P<name>p\d+)\)'
 )
 
-
-def ns2ms(ns):
-    """Nano Seconds to Milliseconds"""
-    return ns / 1e6
-
-
-# ----------------------------
-# PARSER
-# ----------------------------
 LOCAL_RE = re.compile(
     r'^'
     r'(?P<bench>Benchmark[^\s/]+)'          # Benchmark name
@@ -43,21 +35,26 @@ def ns2ms(ns):
 )
 
 
+def ns2ms(ns):
+    """Nano Seconds to Milliseconds"""
+    return ns / 1e6
+
+
 def parse(path: Path, regex=SERVICE_RE):
     rows = []
 
-    for i, line in enumerate(path.read_text().splitlines()):
+    for line in path.read_text().splitlines():
         m = regex.match(line.strip())
         if not m:
-            if i == 9:
-                from IPython import embed
-                embed(colors="Neutral")
             continue
 
         data = m.groupdict()
         bench, *parts = data["bench"].split("/")
 
-        p_dct = dict(p.split("=") for p in parts)
+        if data.get("params"):
+            parts.extend(data["params"].split("/"))
+
+        p_dct = dict(p.split("=", 1) for p in parts if "=" in p)
 
         row = {
             "bench": bench,
@@ -67,7 +64,6 @@ def parse(path: Path, regex=SERVICE_RE):
             **p_dct
         }
 
-        # Parse latency percentiles dynamically
         if "rest" in data:
             for p in RE_PERCENTILE.finditer(data["rest"]):
                 row[f"{p.group('name')} (ms)"] = ns2ms(int(p.group("value")))
@@ -77,6 +73,108 @@ def parse(path: Path, regex=SERVICE_RE):
     return pd.DataFrame(rows)
 
 
+def try_parse(path: Path):
+    """Try SERVICE_RE first, fall back to LOCAL_RE."""
+    df = parse(path, regex=SERVICE_RE)
+    if df.empty:
+        df = parse(path, regex=LOCAL_RE)
+    return df
+
+
+# ----------------------------
+# STRUCTURED PARALLEL LOG PARSER
+# ----------------------------
+ANSI_ESCAPE_RE = re.compile(r'\x1b\[[0-9;]*m')
+
+PARALLEL_RUN_RE = re.compile(
+    r'=== RUN\s+(\S+)/(.+?)_with_(\d+)_workers'
+)
+
+PARALLEL_THROUGHPUT_RE = re.compile(
+    r'Pure Throughput\s+([\d.]+)/s'
+)
+
+PARALLEL_LATENCY_RE = re.compile(
+    r'(Min|P50 \(Median\)|Average|P95|P99\.9|P99|P5|Max)\s+'
+    r'([\d.]+(?:ms|[n\xb5\xc2]+s|s))'
+)
+
+
+def _parse_ms(s: str) -> float:
+    """Parse a duration string (e.g. '36.86ms') into milliseconds."""
+    m = re.match(r'([\d.]+)(.*)', s)
+    val, unit = float(m.group(1)), m.group(2)
+    if unit == 'ms':
+        return val
+    if unit == 'ns':
+        return val / 1e6
+    if unit == 's':
+        return val * 1e3
+    raise ValueError(f"unknown unit: {unit}")
+
+
+def parse_parallel_log(path: Path) -> pd.DataFrame:
+    text = ANSI_ESCAPE_RE.sub('', path.read_text())
+
+    rows: list[dict] = []
+    current: dict = {}
+
+    for line in text.splitlines():
+        line = line.strip()
+
+        m = PARALLEL_RUN_RE.match(line)
+        if m:
+            if current:
+                rows.append(current)
+            bench, params_raw, workers = m.group(
+                1), m.group(2), int(m.group(3))
+            current = {'bench': bench, 'workers': workers}
+            setup_m = re.search(r'Setup\((.+?)\)', params_raw)
+            if setup_m:
+                for token in setup_m.group(1).split(',_'):
+                    token = token.strip('_').lstrip('#')
+                    if '_' in token:
+                        k, v = token.split('_', 1)
+                        current[k] = v
+            continue
+
+        m = PARALLEL_THROUGHPUT_RE.match(line)
+        if m:
+            current['tps'] = float(m.group(1))
+            continue
+
+        m = PARALLEL_LATENCY_RE.match(line)
+        if m:
+            name, raw = m.group(1), m.group(2)
+            ms_val = _parse_ms(raw)
+            key_map = {
+                # 'P50 (Median)': 'p50 (ms)',
+                'P5':           'p5 (ms)',
+                'P95':          'p95 (ms)',
+                'P99':          'p99 (ms)',
+                # 'P99.9':        'p99.9 (ms)',
+                # 'Min':          'min (ms)',
+                # 'Max':          'max (ms)',
+                # 'Average':      'avg (ms)',
+            }
+            if name in key_map:
+                current[key_map[name]] = ms_val
+            continue
+
+        m = re.match(r'Total Ops\s+(\d+)', line)
+        if m:
+            current['iterations'] = int(m.group(1))
+
+    if current:
+        rows.append(current)
+
+    return pd.DataFrame(rows)
+
+
+def has_multi_nc(df: pd.DataFrame) -> bool:
+    return "nc" in df.columns and df["nc"].nunique() > 1
+
+
 # ----------------------------
 # PLOTTING
 # ----------------------------
@@ -95,7 +193,7 @@ def make_figures(df):
         cols = [
             c for c in param_cols
             if bdf[c].notna().any()
-            and not c.endswith("(ms)")   # exclude latency
+            and not c.endswith("(ms)")
         ]
         varying = [c for c in cols if bdf[c].nunique() > 1]
         fixed = [c for c in cols if bdf[c].nunique() <= 1]
@@ -105,14 +203,13 @@ def make_figures(df):
 
         bdf = bdf.copy()
 
-        # Build legend label from varying params
+        # Build legend label
         bdf['series'] = (
             bdf[varying].astype(str).apply(
                 lambda r: ', '.join(f'{k}={v}' for k, v in r.items()), axis=1)
             if varying else bench
         )
 
-        # Aggregate numeric columns
         numeric_cols = [
             c for c in bdf.select_dtypes(include='number').columns
             if c not in ('workers',)
@@ -121,7 +218,7 @@ def make_figures(df):
             bdf.groupby(['series', 'workers'])[numeric_cols]
             .mean()
             .reset_index()
-            .sort_values('workers')
+            .sort_values('workers', ascending=False)
         )
 
         fixed_str = ', '.join(f'{bdf[c].dropna().iloc[0]}' for c in fixed)
@@ -180,51 +277,7 @@ def make_figures(df):
                                   legend=dict(tracegroupgap=10))
             figs.append(fig_lat)
 
-        # -----------------
-        # LATENCY FIGURE 2
-        # -----------------
-        # latency_cols = [c for c in agg.columns if c.endswith('(ms)')]
-
-        # if latency_cols:
-        #     latency_df = agg.melt(
-        #         id_vars=['series', 'workers'],
-        #         value_vars=latency_cols,
-        #         var_name='percentile',
-        #         value_name='latency'
-        #     )
-
-        #     # Clean up the percentile name (p5 (ms) → p5)
-        #     latency_df['percentile'] = latency_df['percentile'].str.replace(
-        #         r' \(ms\)', '', regex=True
-        #     )
-
-        #     fig_lat = px.line(
-        #         latency_df,
-        #         x='workers',
-        #         y='latency',
-        #         color='series',
-        #         line_dash='percentile',
-        #         markers=True,
-        #         title=f'{bench} - Latency{title_suffix}',
-        #         labels={
-        #             'workers': 'Workers (GOMAXPROCS)',
-        #             'latency': 'Latency (ms)',
-        #             'percentile': ''
-        #         }
-        #     )
-
-        #     fig_lat.update_layout(template='plotly_white',
-        #                           hovermode='x unified',
-        #                           legend=dict(
-        #                               title='nc / Percentile',
-        #                               tracegroupgap=10
-        #                           ))
-        #     figs.append(fig_lat)
-
     return figs
-# ----------------------------
-# MAIN
-# ----------------------------
 
 
 def parse_combined(dfs: dict[str, pd.DataFrame]):
@@ -249,7 +302,6 @@ def make_combined_figures(dfs: dict[str, pd.DataFrame],
 
         df = df.copy()
 
-        # Aggregate numeric columns per bench + workers
         numeric_cols = [
             c for c in df.select_dtypes(include="number").columns
             if c != "workers"
@@ -266,9 +318,13 @@ def make_combined_figures(dfs: dict[str, pd.DataFrame],
         # TPS FIGURE
         # -------------------------
         agg["bench"] += "-2machines"
-        for name, df in local_dfs.items():
-            df['bench'] = name
-        agg = pd.concat([agg, *local_dfs.values()], ignore_index=True)
+        local_parts = []
+        for name, ldf in local_dfs.items():
+            ldf = ldf.copy()
+            ldf['bench'] = name
+            local_parts.append(ldf)
+        agg = pd.concat([agg, *local_parts],
+                        ignore_index=True).sort_values(["workers", "tps"], ascending=[True, False])
 
         fig = px.line(
             agg,
@@ -278,7 +334,7 @@ def make_combined_figures(dfs: dict[str, pd.DataFrame],
             markers=True,
             title=f"TPS (nc={nc})",
             labels={
-                "workers": "Workers (GOMAXPROCS)",
+                "workers": "Workers",
                 "tps": "TPS",
                 "bench": ""
             }
@@ -320,49 +376,45 @@ def make_combined_figures(dfs: dict[str, pd.DataFrame],
     return figs
 
 
-def cli():
-    if len(sys.argv) < 2:
-        sys.exit(f"Usage: {sys.argv[0]} <log> [output.html]")
-
-    path = Path(sys.argv[1])
-    out = Path(sys.argv[2]) if len(sys.argv) > 2 else path.with_suffix(".html")
-
-    df = parse(path)
-    figs = make_figures(df)
-
-    html = [
-        fig.to_html(full_html=False,
-                    include_plotlyjs=("cdn" if i == 0 else False))
-        for i, fig in enumerate(figs)
-    ]
-
-    out.write_text("\n".join(html))
-    print(f"Saved {len(figs)} plots to {out}")
-
-
 if __name__ == "__main__":
 
-    directory = Path("bench5")
+    directory = Path(sys.argv[1] if len(sys.argv) > 1 else DEFAULT_BENCH_DIR)
 
-    for path in directory.glob("*.txt"):
-        with st.expander(f"`{path.stem.strip("res_transfer_").upper()}`"):
-            if path.name.startswith("local"):
-                df = parse(path, regex=LOCAL_RE)
-            else:
-                df = parse(path)
+    all_dfs = {}
+    for path in sorted(directory.glob("*.txt")):
+        df = try_parse(path)
+        if df.empty:
+            continue
+        all_dfs[path.stem] = df
+        with st.expander(f"`{path.stem.removeprefix('res_transfer_').upper()}`"):
             for fig in make_figures(df):
                 st.plotly_chart(fig)
 
-    dfs = parse_combined({p.stem.strip("res_transfer_").upper(): parse(p).copy()
-                          for p in directory.glob("*.txt") if not p.name.startswith("local")})
-    figs = make_combined_figures(dfs, local_dfs={p.stem: parse(p, regex=LOCAL_RE).copy()
-                                                 for p in directory.glob("*.txt") if p.name.startswith("local")})
+    multi = {name: df.copy()
+             for name, df in all_dfs.items() if has_multi_nc(df)}
+    single = {name: df.copy()
+              for name, df in all_dfs.items() if not has_multi_nc(df)}
+
+    dfs = parse_combined({
+        name.removeprefix("res_transfer_").upper(): df
+        for name, df in multi.items()
+    })
+    for path in sorted(directory.glob("*.csv")):
+        df = pd.read_csv(path)
+        assert not df.empty
+        with st.expander(f"`{path.stem}`"):
+            st.dataframe(df)
+        single[path.stem] = df
+    for path in sorted(directory.glob("*.log")):
+        df = parse_parallel_log(path)
+        assert not df.empty
+        with st.expander(f"`{path.stem}`"):
+            st.dataframe(df)
+        single[path.stem] = df
+
+    figs = make_combined_figures(dfs, local_dfs=single)
     st.subheader("Combined TPS")
     tabs = st.tabs(list(figs.keys()))
     for fig, tab in zip(figs.values(), tabs):
         with tab:
             st.plotly_chart(fig)
-
-#TODO Add allon snumbers
-#TODO Write down average testdata file (token)
-#Todo: 

token/core/zkatdlog/nogh/v1/validator/bench/transfer_service/transfer_service_bench.go

@@ -52,6 +52,7 @@ func (p *trandferServiceParams) PublicParamsRaw() ([]byte, error) {
 	if err != nil {
 		return nil, fmt.Errorf("failed to base64-decode params file: %w", err)
 	}
+
 	return ppRaw, nil
 }
 
@@ -60,6 +61,7 @@ func (p *trandferServiceParams) PublicParams() (*v1setup.PublicParams, error) {
 	if err != nil {
 		return nil, err
 	}
+
 	return v1setup.NewPublicParamsFromBytes(ppRaw, v1setup.DLogNoGHDriverName, v1setup.ProtocolV1)
 }
 
@@ -69,6 +71,7 @@ func (p *trandferServiceParams) NumInputs() int {
 		n, _ := strconv.Atoi(m[1])
 		return n
 	}
+
 	return -1
 }