results.py

#!/usr/bin/env python3

import sys
import yaml
import os
from tabulate import tabulate
from typing import Dict, List
import json
from dataclasses import dataclass
from datetime import datetime

@dataclass
class FioMetrics:
    read_iops: float
    read_bw_bytes: float
    write_iops: float
    write_bw_bytes: float
    util_pct: float
    runtime_ms: int

@dataclass
class Instance:
    id: str
    type: str
    region: str
    metrics: FioMetrics
    timestamp: datetime

def load_fio_metrics(fio_json_path: str) -> FioMetrics:
    try:
        with open(fio_json_path, "r") as f:
            content = f.read()
            if not content.strip():
                raise ValueError(f"File {fio_json_path} is empty")
            data = json.loads(content)
    except (json.JSONDecodeError, ValueError) as e:
        print(f"Error reading {fio_json_path}: {str(e)}")
        raise
    except Exception as e:
        print(f"Unexpected error reading {fio_json_path}: {str(e)}")
        raise
    
    job = data["jobs"][0]
    return FioMetrics(
        read_iops=job["read"]["iops"],
        read_bw_bytes=job["read"]["bw_bytes"],
        write_iops=job["write"]["iops"],
        write_bw_bytes=job["write"]["bw_bytes"],
        util_pct=data.get("disk_util", [{"util": 0}])[0]["util"],
        runtime_ms=job["job_runtime"]
    )

def load_run(run_dir: str) -> List[Instance]:
    # Load state file
    with open(os.path.join(run_dir, "state.yaml"), "r") as f:
        state = yaml.safe_load(f)

    instances: List[Instance] = []
    
    # Process each instance directory
    for instance in state["instances"]:
        instance_dir = os.path.join(run_dir, instance["id"])
        fio_json_path = os.path.join(instance_dir, "fio.json")
        
        if not os.path.exists(fio_json_path):
            print(f"Warning: No fio.json found for instance {instance['id']}")
            continue

        metrics = load_fio_metrics(fio_json_path)
        instances.append(Instance(
            id=instance["id"],
            type=instance["type"],
            region=instance["region"],
            metrics=metrics,
            timestamp=datetime.fromtimestamp(os.path.getctime(fio_json_path))
        ))

    return instances

def bytes_to_readable(bytes_per_sec: float) -> str:
    for unit in ['B/s', 'KB/s', 'MB/s', 'GB/s']:
        if bytes_per_sec < 1024.0:
            return f"{bytes_per_sec:,.2f} {unit}"
        bytes_per_sec /= 1024.0
    return f"{bytes_per_sec:,.2f} TB/s"

def print_results(instances: List[Instance]):
    headers = [
        "Instance Type", 
        "Region", 
        "Read IOPS", 
        "Write IOPS", 
        "Total IOPS",
        "Read BW",
        "Write BW",
        "Disk Util %",
        "Runtime"
    ]
    rows = []

    # Group by instance type
    by_type: Dict[str, List[Instance]] = {}
    for instance in instances:
        if instance.type not in by_type:
            by_type[instance.type] = []
        by_type[instance.type].append(instance)

    # Calculate averages and create rows
    for type_name, type_instances in by_type.items():
        avg_read_iops = sum(i.metrics.read_iops for i in type_instances) / len(type_instances)
        avg_write_iops = sum(i.metrics.write_iops for i in type_instances) / len(type_instances)
        avg_read_bw = sum(i.metrics.read_bw_bytes for i in type_instances) / len(type_instances)
        avg_write_bw = sum(i.metrics.write_bw_bytes for i in type_instances) / len(type_instances)
        avg_util = sum(i.metrics.util_pct for i in type_instances) / len(type_instances)
        avg_runtime = sum(i.metrics.runtime_ms for i in type_instances) / len(type_instances)

        rows.append([
            type_name,
            type_instances[0].region,
            f"{avg_read_iops:,.2f}",
            f"{avg_write_iops:,.2f}",
            f"{avg_read_iops + avg_write_iops:,.2f}",
            bytes_to_readable(avg_read_bw),
            bytes_to_readable(avg_write_bw),
            f"{avg_util:.2f}%",
            f"{avg_runtime/1000:.1f}s"
        ])

    # Sort by total IOPS
    rows.sort(key=lambda x: float(x[4].replace(",", "")), reverse=True)

    # Print table
    print(tabulate(rows, headers=headers, tablefmt="grid"))

def main():
    if len(sys.argv) != 2:
        print(f"Usage: {sys.argv[0]} <run_directory>")
        sys.exit(1)

    run_dir = sys.argv[1]
    if not os.path.isdir(run_dir):
        print(f"Error: {run_dir} is not a directory")
        sys.exit(1)

    instances = load_run(run_dir)
    print_results(instances)

if __name__ == "__main__":
    main()