AIPerf Server Metrics Parquet Export Schema

1
import pandas as pd
2
3
df = pd.read_parquet('server_metrics_export.parquet')
4
5
# Filter to gauge metrics
6
gauges = df[df['metric_type'] == 'gauge']
7
8
# Time-series plot
9
kv_usage = df[df['metric_name'] == 'vllm:kv_cache_usage_perc']
10
kv_usage.plot(x='timestamp_ns', y='value', title='KV Cache Usage')
11
12
# Pivot histogram buckets
13
hist = df[df['metric_name'] == 'vllm:e2e_request_latency_seconds']
14
pivot = hist.pivot(index='timestamp_ns', columns='bucket_le', values='bucket_count')

1
import polars as pl
2
3
df = pl.read_parquet('server_metrics_export.parquet')
4
5
# Filter and aggregate
6
result = (
7
    df.filter(pl.col('metric_type') == 'gauge')
8
    .group_by('metric_name')
9
    .agg([
10
        pl.col('value').mean().alias('avg'),
11
        pl.col('value').max().alias('max'),
12
    ])
13
)
14
15
# Lazy scan for large files
16
lazy = pl.scan_parquet('artifacts/*/server_metrics_export.parquet')
17
result = lazy.filter(pl.col('metric_name') == 'vllm:kv_cache_usage_perc').collect()

1
import pyarrow.parquet as pq
2
import json
3
4
metadata = pq.read_metadata('server_metrics_export.parquet')
5
schema_metadata = metadata.schema.to_arrow_schema().metadata
6
7
# Access specific fields
8
benchmark_id = schema_metadata[b'aiperf.benchmark_id'].decode()
9
config = json.loads(schema_metadata[b'aiperf.input_config'])
10
label_columns = json.loads(schema_metadata[b'aiperf.label_columns'])

1
# pandas
2
import pandas as pd
3
from pathlib import Path
4
5
dfs = [pd.read_parquet(p) for p in Path('.').glob('run_*/server_metrics_export.parquet')]
6
combined = pd.concat(dfs, ignore_index=True)

1
import numpy as np
2
3
def estimate_percentile(bucket_les, bucket_counts, percentile):
4
    """Estimate percentile from histogram buckets using linear interpolation."""
5
    # Convert bucket_le strings to floats (handle +Inf)
6
    bounds = [float(b) if b != '+Inf' else np.inf for b in bucket_les]
7
    counts = np.array(bucket_counts)
8
9
    total = counts[-1]  # +Inf bucket has cumulative total
10
    target = total * (percentile / 100)
11
12
    for i, (le, count) in enumerate(zip(bounds, counts)):
13
        if count >= target:
14
            if i == 0:
15
                return le
16
            prev_le = bounds[i-1] if i > 0 else 0
17
            prev_count = counts[i-1] if i > 0 else 0
18
            # Linear interpolation within bucket
19
            fraction = (target - prev_count) / (count - prev_count) if count > prev_count else 0
20
            return prev_le + fraction * (le - prev_le)
21
    return bounds[-2]  # Return last finite bound

1
# Polars lazy scan
2
import polars as pl
3
df = pl.scan_parquet('server_metrics_export.parquet') \
4
    .filter(pl.col('metric_name') == 'vllm:kv_cache_usage_perc') \
5
    .collect()
6
7
# DuckDB direct query (doesn't load entire file)
8
import duckdb
9
result = duckdb.query("""
10
    SELECT AVG(value) FROM 'server_metrics_export.parquet'
11
    WHERE metric_name = 'vllm:kv_cache_usage_perc'
12
""").fetchone()