feat: add iavlx

.gitignore

@@ -65,3 +65,5 @@ debug_container.log
 *.synctex.gz
 /x/genutil/config/priv_validator_key.json
 /x/genutil/data/priv_validator_state.json
+/.envrc
+/.env

.python-version

@@ -0,0 +1 @@
+3.13

Makefile

@@ -492,13 +492,17 @@ localnet-debug: localnet-stop localnet-build-dlv localnet-build-nodes
 
 .PHONY: localnet-start localnet-stop localnet-debug localnet-build-env localnet-build-dlv localnet-build-nodes
 
-test-system: build-v53 build
+build-system-test-current: build
+	mkdir -p ./tests/systemtests/binaries/
+	cp $(BUILDDIR)/simd ./tests/systemtests/binaries/
+
+test-system: build-v53 build-system-test-current
 	mkdir -p ./tests/systemtests/binaries/
 	cp $(BUILDDIR)/simd ./tests/systemtests/binaries/
 	mkdir -p ./tests/systemtests/binaries/v0.53
 	mv $(BUILDDIR)/simdv53 ./tests/systemtests/binaries/v0.53/simd
 	$(MAKE) -C tests/systemtests test
-.PHONY: test-system
+.PHONY: test-system build-system-test-current
 
 # build-v53 checks out the v0.53.x branch, builds the binary, and renames it to simdv53.
 build-v53:

analysis/analysis.py

@@ -0,0 +1,124 @@
+"""Analysis functions for OpenTelemetry trace and metrics data."""
+
+import duckdb
+from datetime import datetime
+from pydantic import BaseModel
+import pandas as pd
+import plotly.graph_objects as go
+from typing import Dict
+
+# Type alias for runs dictionary (run_name -> DuckDB connection)
+Runs = Dict[str, duckdb.DuckDBPyConnection]
+
+
+class BlockSummary(BaseModel):
+    """Summary of block execution."""
+    start_time: datetime
+    end_time: datetime
+    total_duration_seconds: float
+    block_count: int
+
+
+def block_summary(con: duckdb.DuckDBPyConnection) -> BlockSummary:
+    """
+    Generate a high-level summary of block execution.
+
+    Args:
+        con: DuckDB connection with spans view loaded
+
+    Returns:
+        BlockSummary object with:
+        - start_time: Start time of first block
+        - end_time: End time of last block
+        - total_duration_seconds: Total duration from first block start to last block end
+        - block_count: Total number of blocks processed
+
+    Example:
+        >>> from analysis.read_otel import load_otel_data
+        >>> con = load_otel_data('/path/to/data')
+        >>> summary = block_summary(con)
+        >>> print(f"Processed {summary.block_count} blocks in {summary.total_duration_seconds:.2f}s")
+    """
+    result = con.sql("""
+        SELECT
+            MIN(start_time) AS start_time,
+            MAX(end_time) AS end_time,
+            EXTRACT(EPOCH FROM (MAX(end_time) - MIN(start_time))) AS total_duration_seconds,
+            COUNT(*) AS block_count
+        FROM spans
+        WHERE span_name = 'Block' AND scope = 'cosmos-sdk/baseapp'
+    """).fetchone()
+
+    return BlockSummary(
+        start_time=result[0],
+        end_time=result[1],
+        total_duration_seconds=result[2],
+        block_count=result[3],
+    )
+
+
+def block_durations(con: duckdb.DuckDBPyConnection, span_name: str = 'Block') -> pd.DataFrame:
+    """
+    Get duration for each block.
+
+    Args:
+        con: DuckDB connection with spans view loaded
+
+    Returns:
+        DataFrame with columns:
+        - block_number: Sequential block number (1-indexed)
+        - duration_ms: Block duration in milliseconds
+
+    Example:
+        >>> from analysis.read_otel import load_otel_data
+        >>> con = load_otel_data('/path/to/data')
+        >>> df = block_durations(con)
+        >>> df.head()
+    """
+    return con.sql("""
+        SELECT
+            ROW_NUMBER() OVER (ORDER BY start_time) AS block_number,
+            EXTRACT(EPOCH FROM duration) * 1000 AS duration_ms
+        FROM spans
+        WHERE span_name = ? AND scope = 'cosmos-sdk/baseapp'
+        ORDER BY start_time
+    """, params=[span_name]).df()
+
+
+def plot_block_durations(runs: Runs, span_name: str = 'Block') -> go.Figure:
+    """
+    Create a plotly line chart comparing block durations across runs.
+
+    Args:
+        runs: Dictionary mapping run name to DuckDB connection
+
+    Returns:
+        Plotly Figure object with block duration traces for each run
+
+    Example:
+        >>> from analysis.read_otel import load_otel_runs
+        >>> runs = load_otel_runs('/path/to/data')
+        >>> fig = plot_block_durations(runs)
+        >>> fig.show()
+    """
+    fig = go.Figure()
+
+    for run_name, con in runs.items():
+        df = block_durations(con, span_name)
+        fig.add_trace(go.Scatter(
+            x=df['block_number'],
+            y=df['duration_ms'],
+            mode='lines',
+            name=run_name,
+            line=dict(width=2)
+        ))
+
+    fig.update_layout(
+        title=f'{span_name} Duration Comparison',
+        xaxis_title='Block Number',
+        yaxis_title='Duration (ms)',
+        hovermode='x unified',
+        template='plotly_white'
+    )
+
+    return fig

analysis/read_otel.py

@@ -0,0 +1,128 @@
+"""Load OpenTelemetry JSONL data into DuckDB views."""
+
+import duckdb
+from pathlib import Path
+from typing import Dict
+
+
+def load_otel_data(data_path: str | Path) -> duckdb.DuckDBPyConnection:
+    """
+    Load OpenTelemetry data from a directory containing trace.jsonl, logs.jsonl, and metrics.jsonl.
+
+    Creates three views in the returned DuckDB connection:
+    - spans: flattened trace data
+    - logs: flattened log data
+    - metrics: flattened metrics data
+
+    Args:
+        data_path: Path to directory containing the JSONL files
+
+    Returns:
+        DuckDB connection with views created
+
+    Example:
+        >>> con = load_otel_data('/path/to/data')
+        >>> con.sql("SELECT span_name, count(*) FROM spans GROUP BY span_name").show()
+    """
+    data_path = Path(data_path)
+    con = duckdb.connect(':memory:')
+
+    # Create spans view from trace.jsonl
+    trace_file = data_path / 'trace.jsonl'
+    if trace_file.exists():
+        con.execute(f"""
+            CREATE VIEW spans AS
+            SELECT
+                Name AS span_name,
+                SpanContext.TraceID AS trace_id,
+                SpanContext.SpanID AS span_id,
+                Parent.SpanID AS parent_span_id,
+                CAST(StartTime AS TIMESTAMPTZ) AS start_time,
+                CAST(EndTime AS TIMESTAMPTZ) AS end_time,
+                CAST(EndTime AS TIMESTAMPTZ) - CAST(StartTime AS TIMESTAMPTZ) AS duration,
+                InstrumentationScope.Name AS scope,
+                ChildSpanCount AS child_span_count,
+                Attributes,
+                Resource,
+                Status
+            FROM read_ndjson_auto('{trace_file}')
+        """)
+
+    # Create logs view from logs.jsonl
+    logs_file = data_path / 'logs.jsonl'
+    if logs_file.exists():
+        con.execute(f"""
+            CREATE VIEW logs AS
+            SELECT
+                CAST(Timestamp AS TIMESTAMPTZ) AS timestamp,
+                CAST(ObservedTimestamp AS TIMESTAMPTZ) AS observed_timestamp,
+                Severity AS severity,
+                SeverityText AS severity_text,
+                Body.Value AS body,
+                TraceID AS trace_id,
+                SpanID AS span_id,
+                Attributes,
+                Resource,
+                Scope
+            FROM read_ndjson_auto('{logs_file}')
+        """)
+
+    # Create metrics view from metrics.jsonl (if file exists and has data)
+    metrics_file = data_path / 'metrics.jsonl'
+    if metrics_file.exists() and metrics_file.stat().st_size > 0:
+        # Flatten the deeply nested metrics structure
+        # Structure: Resource → ScopeMetrics[] → Metrics[] → Data → DataPoints[]
+        con.execute(f"""
+            CREATE VIEW metrics AS
+            SELECT
+                scope_metric.Scope.Name AS scope_name,
+                scope_metric.Scope.Version AS scope_version,
+                metric.Name AS metric_name,
+                metric.Description AS metric_description,
+                metric.Unit AS unit,
+                metric.Data.Temporality AS temporality,
+                metric.Data.IsMonotonic AS is_monotonic,
+                CAST(dp.Time AS TIMESTAMPTZ) AS time,
+                CAST(dp.StartTime AS TIMESTAMPTZ) AS start_time,
+                dp.Value AS value,
+                dp.Count AS count,
+                dp.Sum AS sum,
+                dp.Min AS min,
+                dp.Max AS max,
+                dp.Attributes AS attributes,
+                raw.Resource AS resource
+            FROM read_ndjson_auto('{metrics_file}') AS raw
+            CROSS JOIN UNNEST(raw.ScopeMetrics) AS t(scope_metric)
+            CROSS JOIN UNNEST(scope_metric.Metrics) AS t2(metric)
+            CROSS JOIN UNNEST(metric.Data.DataPoints) AS t3(dp)
+        """)
+
+    return con
+
+
+def load_otel_runs(runs_dir: str | Path) -> Dict[str, duckdb.DuckDBPyConnection]:
+    """
+    Load OpenTelemetry data from multiple run directories.
+
+    Args:
+        runs_dir: Path to directory containing subdirectories with OTEL data
+                  Each subdirectory should contain trace.jsonl, logs.jsonl, metrics.jsonl
+
+    Returns:
+        Dictionary mapping run name (subdirectory name) to DuckDB connection
+
+    Example:
+        >>> connections = load_otel_runs('/Users/arc/iavl-bench-data/sims')
+        >>> # Returns: {'iavlx': <connection>, 'iavl1': <connection>}
+        >>> connections['iavlx'].sql("SELECT count(*) FROM spans").show()
+    """
+    runs_dir = Path(runs_dir)
+    connections = {}
+
+    for subdir in runs_dir.iterdir():
+        if subdir.is_dir():
+            # Check if it has trace.jsonl to confirm it's a valid run directory
+            if (subdir / 'trace.jsonl').exists():
+                connections[subdir.name] = load_otel_data(subdir)
+
+    return connections