Initial commit: 2125_GCE project
This commit is contained in:
GlyphRunner System
Executable
+532
@@ -0,0 +1,532 @@
|
||||
#!/usr/bin/env python3
|
||||
"""10,000 Parallel Instance Extreme Stress Test with 100+ Program Variants
|
||||
|
||||
Generates 100+ unique XIC program variations covering:
|
||||
- Deep control flow (IF/MATCH/LOOP combinations)
|
||||
- Aggressive guardrail triggers
|
||||
- Symbolic execution under stress
|
||||
- Mixed workloads with varying glyph contexts
|
||||
- Resource-intensive operations
|
||||
- Predicate evaluation at scale
|
||||
- Chain scheduling across hundreds of branches
|
||||
|
||||
Executes 10,000 parallel instances for 10 minutes, collecting:
|
||||
- Execution count per program variant
|
||||
- Guardrail trigger events
|
||||
- Error rates
|
||||
- VRAM usage peaks
|
||||
- Throughput metrics
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
import time
|
||||
import random
|
||||
import threading
|
||||
import concurrent.futures
|
||||
import psutil
|
||||
import traceback
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from typing import Dict, List, Any
|
||||
|
||||
# Configuration
|
||||
SUPERDAVE_ROOT = Path(__file__).parent
|
||||
PROGRAMS_DIR = SUPERDAVE_ROOT / "programs"
|
||||
VARIANTS = 120 # 100+ unique program variants
|
||||
INSTANCES = 10000
|
||||
DURATION_SECS = 600 # 10 minutes
|
||||
MAX_WORKERS = 1000 # Thread pool workers (OS manages scheduling)
|
||||
|
||||
# Metrics collection
|
||||
metrics_lock = threading.Lock()
|
||||
metrics = {
|
||||
"total_executions": 0,
|
||||
"successful_executions": 0,
|
||||
"failed_executions": 0,
|
||||
"guardrail_triggers": 0,
|
||||
"variant_counters": {},
|
||||
"vram_peaks": [],
|
||||
"error_log": [],
|
||||
"start_time": time.time(),
|
||||
"end_time": None,
|
||||
}
|
||||
|
||||
|
||||
def generate_program_variants() -> List[str]:
|
||||
"""Generate 100+ unique XIC program variants."""
|
||||
variants = []
|
||||
|
||||
# Variant group 1: Pure IF branching with varying thresholds
|
||||
for i in range(15):
|
||||
threshold = 0.3 + (i * 0.04) # 0.3 to 0.9
|
||||
prog = {
|
||||
"magic": "GXIC1",
|
||||
"version": 1,
|
||||
"model": "",
|
||||
"entrypoint": "main",
|
||||
"symbols": {"main": 0, "branch_a": 5, "branch_b": 10, "end": 13},
|
||||
"instructions": [
|
||||
{"op": "SET_MODE", "args": ["symbolic"]},
|
||||
{"op": "SET_CONTEXT", "args": ["variant", f"if_threshold_{threshold:.2f}"]},
|
||||
{"op": "PUSH_GLYPH_CONTEXT", "args": [f"glyph://variant_{i}_a"]},
|
||||
{"op": "PUSH_GLYPH_CONTEXT", "args": [f"glyph://variant_{i}_b"]},
|
||||
{"op": "RUN_PROMPT", "args": [f"Analyze variant {i} with threshold {threshold:.2f}"]},
|
||||
{"op": "IF", "args": [f"fused.global_resonance_score > {threshold}", "branch_a", "branch_b"]},
|
||||
{"op": "CHAIN", "args": ["branch_a"]},
|
||||
{"op": "LOG", "args": [f"Branch A for variant {i}"]},
|
||||
{"op": "RUN_PROMPT", "args": ["Deep analysis path A"]},
|
||||
{"op": "CHAIN", "args": ["end"]},
|
||||
{"op": "CHAIN", "args": ["branch_b"]},
|
||||
{"op": "LOG", "args": [f"Branch B for variant {i}"]},
|
||||
{"op": "RUN_PROMPT", "args": ["Alternative path B"]},
|
||||
{"op": "CHAIN", "args": ["end"]},
|
||||
{"op": "CHAIN", "args": ["end"]},
|
||||
{"op": "LOG", "args": ["IF variant complete"]},
|
||||
],
|
||||
}
|
||||
path = PROGRAMS_DIR / f"stress_if_v{i}.gx.json"
|
||||
path.write_text(json.dumps(prog, indent=2))
|
||||
variants.append(str(path))
|
||||
|
||||
# Variant group 2: Aggressive LOOP with varying max_iter
|
||||
for i in range(15):
|
||||
max_iter = 3 + (i % 8) # 3-10 iterations
|
||||
prog = {
|
||||
"magic": "GXIC1",
|
||||
"version": 1,
|
||||
"model": "",
|
||||
"entrypoint": "main",
|
||||
"symbols": {"main": 0, "loop_body": 7, "end": 12},
|
||||
"instructions": [
|
||||
{"op": "SET_MODE", "args": ["symbolic"]},
|
||||
{"op": "SET_PARAM", "args": ["max_loop_iterations", max_iter]},
|
||||
{"op": "SET_CONTEXT", "args": ["variant", f"loop_iter_{max_iter}"]},
|
||||
{"op": "PUSH_GLYPH_CONTEXT", "args": [f"glyph://loop_{i}"]},
|
||||
{"op": "LOG", "args": [f"Starting LOOP variant {i} with max_iter={max_iter}"]},
|
||||
{"op": "LOOP", "args": [f"fused.global_resonance_score > 0.{5 + (i%4)}", "loop_body", max_iter]},
|
||||
{"op": "CHAIN", "args": ["loop_body"]},
|
||||
{"op": "RUN_PROMPT", "args": [f"Iterative refinement cycle {i}"]},
|
||||
{"op": "GET_GLYPH_RESONANCE", "args": [f"glyph://loop_{i}", "global"]},
|
||||
{"op": "LOG", "args": ["Loop iteration done"]},
|
||||
{"op": "CHAIN", "args": ["end"]},
|
||||
{"op": "CHAIN", "args": ["end"]},
|
||||
{"op": "LOG", "args": ["LOOP variant complete"]},
|
||||
],
|
||||
}
|
||||
path = PROGRAMS_DIR / f"stress_loop_v{i}.gx.json"
|
||||
path.write_text(json.dumps(prog, indent=2))
|
||||
variants.append(str(path))
|
||||
|
||||
# Variant group 3: MATCH with multiple patterns
|
||||
for i in range(15):
|
||||
patterns = [f"glyph://pattern_{j}" for j in range(i % 5 + 1)]
|
||||
prog = {
|
||||
"magic": "GXIC1",
|
||||
"version": 1,
|
||||
"model": "",
|
||||
"entrypoint": "main",
|
||||
"symbols": {"main": 0, "match_true": 6, "end": 10},
|
||||
"instructions": [
|
||||
{"op": "SET_MODE", "args": ["symbolic"]},
|
||||
{"op": "SET_CONTEXT", "args": ["variant", f"match_pattern_{i}"]},
|
||||
{"op": "PUSH_GLYPH_CONTEXT", "args": [f"glyph://match_{i}"]},
|
||||
{"op": "RUN_PROMPT", "args": [f"Setup MATCH variant {i}"]},
|
||||
{"op": "MATCH", "args": ["fused.glyph_ids", patterns[0], "match_true"]},
|
||||
{"op": "CHAIN", "args": ["match_true"]},
|
||||
{"op": "LOG", "args": ["Pattern matched"]},
|
||||
{"op": "RUN_PROMPT", "args": ["Post-match analysis"]},
|
||||
{"op": "CHAIN", "args": ["end"]},
|
||||
{"op": "CHAIN", "args": ["end"]},
|
||||
{"op": "LOG", "args": ["MATCH variant complete"]},
|
||||
],
|
||||
}
|
||||
path = PROGRAMS_DIR / f"stress_match_v{i}.gx.json"
|
||||
path.write_text(json.dumps(prog, indent=2))
|
||||
variants.append(str(path))
|
||||
|
||||
# Variant group 4: Nested control flow (IF inside LOOP)
|
||||
for i in range(15):
|
||||
prog = {
|
||||
"magic": "GXIC1",
|
||||
"version": 1,
|
||||
"model": "",
|
||||
"entrypoint": "main",
|
||||
"symbols": {
|
||||
"main": 0, "loop_body": 8, "if_true": 12, "if_false": 15, "end": 18
|
||||
},
|
||||
"instructions": [
|
||||
{"op": "SET_MODE", "args": ["symbolic"]},
|
||||
{"op": "SET_PARAM", "args": ["max_loop_iterations", 4]},
|
||||
{"op": "SET_CONTEXT", "args": ["variant", f"nested_{i}"]},
|
||||
{"op": "PUSH_GLYPH_CONTEXT", "args": [f"glyph://nested_{i}"]},
|
||||
{"op": "LOOP", "args": ["fused.global_resonance_score > 0.5", "loop_body", 4]},
|
||||
{"op": "CHAIN", "args": ["loop_body"]},
|
||||
{"op": "RUN_PROMPT", "args": [f"Nested variant {i} cycle"]},
|
||||
{"op": "IF", "args": ["fused.glyph_count > 0", "if_true", "if_false"]},
|
||||
{"op": "CHAIN", "args": ["if_true"]},
|
||||
{"op": "LOG", "args": ["Nested IF true"]},
|
||||
{"op": "RUN_PROMPT", "args": ["Nested true path"]},
|
||||
{"op": "CHAIN", "args": ["end"]},
|
||||
{"op": "CHAIN", "args": ["if_false"]},
|
||||
{"op": "LOG", "args": ["Nested IF false"]},
|
||||
{"op": "RUN_PROMPT", "args": ["Nested false path"]},
|
||||
{"op": "CHAIN", "args": ["end"]},
|
||||
{"op": "CHAIN", "args": ["end"]},
|
||||
{"op": "CHAIN", "args": ["end"]},
|
||||
{"op": "LOG", "args": ["Nested variant complete"]},
|
||||
],
|
||||
}
|
||||
path = PROGRAMS_DIR / f"stress_nested_v{i}.gx.json"
|
||||
path.write_text(json.dumps(prog, indent=2))
|
||||
variants.append(str(path))
|
||||
|
||||
# Variant group 5: Multi-chain complex control flow
|
||||
for i in range(15):
|
||||
chain_count = 3 + (i % 4)
|
||||
chains = {f"chain_{j}": 5 + (j * 4) for j in range(chain_count)}
|
||||
chains["end"] = 100
|
||||
|
||||
instructions = [
|
||||
{"op": "SET_MODE", "args": ["symbolic"]},
|
||||
{"op": "SET_CONTEXT", "args": ["variant", f"multichain_{i}"]},
|
||||
]
|
||||
|
||||
for j in range(chain_count):
|
||||
instructions.append({"op": "PUSH_GLYPH_CONTEXT", "args": [f"glyph://chain_{j}_{i}"]})
|
||||
|
||||
instructions.extend([
|
||||
{"op": "RUN_PROMPT", "args": [f"Multichain variant {i} setup"]},
|
||||
])
|
||||
|
||||
for j in range(chain_count):
|
||||
instructions.extend([
|
||||
{"op": "CHAIN", "args": [f"chain_{j}"]},
|
||||
{"op": "LOG", "args": [f"Chain {j} execution"]},
|
||||
{"op": "RUN_PROMPT", "args": [f"Chain {j} processing"]},
|
||||
])
|
||||
|
||||
instructions.append({"op": "CHAIN", "args": ["end"]})
|
||||
instructions.append({"op": "LOG", "args": ["Multichain complete"]})
|
||||
|
||||
prog = {
|
||||
"magic": "GXIC1",
|
||||
"version": 1,
|
||||
"model": "",
|
||||
"entrypoint": "main",
|
||||
"symbols": chains,
|
||||
"instructions": instructions,
|
||||
}
|
||||
path = PROGRAMS_DIR / f"stress_multichain_v{i}.gx.json"
|
||||
path.write_text(json.dumps(prog, indent=2))
|
||||
variants.append(str(path))
|
||||
|
||||
# Variant group 6: Heavy guardrail stress (intentionally violate limits)
|
||||
for i in range(15):
|
||||
prog = {
|
||||
"magic": "GXIC1",
|
||||
"version": 1,
|
||||
"model": "",
|
||||
"entrypoint": "main",
|
||||
"symbols": {"main": 0, "loop_a": 7, "end": 13},
|
||||
"instructions": [
|
||||
{"op": "SET_MODE", "args": ["symbolic"]},
|
||||
{"op": "SET_PARAM", "args": ["max_loop_iterations", 2]},
|
||||
{"op": "SET_PARAM", "args": ["max_total_steps", 50 + i]},
|
||||
{"op": "SET_CONTEXT", "args": ["variant", f"guardrail_stress_{i}"]},
|
||||
{"op": "PUSH_GLYPH_CONTEXT", "args": [f"glyph://guardrail_{i}"]},
|
||||
{"op": "LOOP", "args": ["fused.global_resonance_score > 0.4", "loop_a", 10]},
|
||||
{"op": "CHAIN", "args": ["loop_a"]},
|
||||
{"op": "RUN_PROMPT", "args": ["Heavy iteration under guardrail stress"]},
|
||||
{"op": "RUN_PROMPT", "args": ["Secondary prompt in loop"]},
|
||||
{"op": "GET_GLYPH_RESONANCE", "args": [f"glyph://guardrail_{i}", "global"]},
|
||||
{"op": "CHAIN", "args": ["end"]},
|
||||
{"op": "CHAIN", "args": ["end"]},
|
||||
{"op": "LOG", "args": ["Guardrail stress variant complete"]},
|
||||
],
|
||||
}
|
||||
path = PROGRAMS_DIR / f"stress_guardrail_v{i}.gx.json"
|
||||
path.write_text(json.dumps(prog, indent=2))
|
||||
variants.append(str(path))
|
||||
|
||||
# Variant group 7: Complex predicate evaluation
|
||||
for i in range(15):
|
||||
predicates = [
|
||||
"fused.global_resonance_score > 0.7",
|
||||
"fused.glyph_count >= 1",
|
||||
"fused.global_resonance_score > 0.5 and fused.glyph_count > 0",
|
||||
"dominant_contains('glyph://test')",
|
||||
"not (fused.global_resonance_score < 0.3)",
|
||||
]
|
||||
pred = predicates[i % len(predicates)]
|
||||
|
||||
prog = {
|
||||
"magic": "GXIC1",
|
||||
"version": 1,
|
||||
"model": "",
|
||||
"entrypoint": "main",
|
||||
"symbols": {"main": 0, "true_b": 5, "false_b": 9, "end": 12},
|
||||
"instructions": [
|
||||
{"op": "SET_MODE", "args": ["symbolic"]},
|
||||
{"op": "SET_CONTEXT", "args": ["variant", f"predicate_{i}"]},
|
||||
{"op": "RUN_PROMPT", "args": [f"Setup for predicate test {i}"]},
|
||||
{"op": "IF", "args": [pred, "true_b", "false_b"]},
|
||||
{"op": "CHAIN", "args": ["true_b"]},
|
||||
{"op": "LOG", "args": [f"Predicate {i} evaluated true"]},
|
||||
{"op": "RUN_PROMPT", "args": ["True path execution"]},
|
||||
{"op": "CHAIN", "args": ["end"]},
|
||||
{"op": "CHAIN", "args": ["false_b"]},
|
||||
{"op": "LOG", "args": [f"Predicate {i} evaluated false"]},
|
||||
{"op": "RUN_PROMPT", "args": ["False path execution"]},
|
||||
{"op": "CHAIN", "args": ["end"]},
|
||||
{"op": "CHAIN", "args": ["end"]},
|
||||
{"op": "LOG", "args": ["Predicate variant complete"]},
|
||||
],
|
||||
}
|
||||
path = PROGRAMS_DIR / f"stress_predicate_v{i}.gx.json"
|
||||
path.write_text(json.dumps(prog, indent=2))
|
||||
variants.append(str(path))
|
||||
|
||||
# Variant group 8: Memory-intensive glyph stacking
|
||||
for i in range(10):
|
||||
glyph_count = 5 + (i * 2)
|
||||
instructions = [
|
||||
{"op": "SET_MODE", "args": ["symbolic"]},
|
||||
{"op": "SET_CONTEXT", "args": ["variant", f"glyph_stack_{i}_{glyph_count}"]},
|
||||
]
|
||||
|
||||
for j in range(glyph_count):
|
||||
instructions.append({"op": "PUSH_GLYPH_CONTEXT", "args": [f"glyph://stack_{i}_{j}"]})
|
||||
|
||||
instructions.extend([
|
||||
{"op": "RUN_PROMPT", "args": [f"Analyze {glyph_count} glyphs in variant {i}"]},
|
||||
{"op": "LOG", "args": [f"Glyph stack {i} complete with {glyph_count} glyphs"]},
|
||||
])
|
||||
|
||||
prog = {
|
||||
"magic": "GXIC1",
|
||||
"version": 1,
|
||||
"model": "",
|
||||
"entrypoint": "main",
|
||||
"symbols": {"main": 0},
|
||||
"instructions": instructions,
|
||||
}
|
||||
path = PROGRAMS_DIR / f"stress_glyph_stack_v{i}.gx.json"
|
||||
path.write_text(json.dumps(prog, indent=2))
|
||||
variants.append(str(path))
|
||||
|
||||
return variants
|
||||
|
||||
|
||||
def run_stress_instance(instance_id: int, program_path: str) -> Dict[str, Any]:
|
||||
"""Execute a single stress test instance."""
|
||||
global metrics
|
||||
|
||||
try:
|
||||
from xic_executor import run_xic
|
||||
|
||||
start_time = time.time()
|
||||
|
||||
# Record variant execution
|
||||
with metrics_lock:
|
||||
variant_name = Path(program_path).stem
|
||||
metrics["variant_counters"][variant_name] = metrics["variant_counters"].get(variant_name, 0) + 1
|
||||
|
||||
# Run the XIC program
|
||||
try:
|
||||
ctx = run_xic(program_path, debug=False)
|
||||
elapsed = time.time() - start_time
|
||||
|
||||
with metrics_lock:
|
||||
metrics["total_executions"] += 1
|
||||
metrics["successful_executions"] += 1
|
||||
|
||||
# Check if guardrails were triggered
|
||||
if ctx._state.get("guardrails"):
|
||||
metrics["guardrail_triggers"] += len(ctx._state["guardrails"])
|
||||
|
||||
return {
|
||||
"instance_id": instance_id,
|
||||
"status": "success",
|
||||
"program": Path(program_path).stem,
|
||||
"elapsed": elapsed,
|
||||
"guardrails_triggered": len(ctx._state.get("guardrails", [])),
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
elapsed = time.time() - start_time
|
||||
with metrics_lock:
|
||||
metrics["total_executions"] += 1
|
||||
metrics["failed_executions"] += 1
|
||||
metrics["error_log"].append({
|
||||
"instance": instance_id,
|
||||
"program": Path(program_path).stem,
|
||||
"error": str(e)[:100],
|
||||
})
|
||||
|
||||
return {
|
||||
"instance_id": instance_id,
|
||||
"status": "error",
|
||||
"program": Path(program_path).stem,
|
||||
"error": str(e)[:50],
|
||||
"elapsed": elapsed,
|
||||
}
|
||||
|
||||
except ImportError:
|
||||
with metrics_lock:
|
||||
metrics["total_executions"] += 1
|
||||
metrics["failed_executions"] += 1
|
||||
return {"instance_id": instance_id, "status": "import_error"}
|
||||
|
||||
|
||||
def monitor_vram():
|
||||
"""Monitor VRAM usage during stress test."""
|
||||
while time.time() - metrics["start_time"] < DURATION_SECS:
|
||||
try:
|
||||
vram_info = psutil.virtual_memory()
|
||||
with metrics_lock:
|
||||
metrics["vram_peaks"].append({
|
||||
"timestamp": time.time() - metrics["start_time"],
|
||||
"percent": vram_info.percent,
|
||||
"used_gb": vram_info.used / (1024**3),
|
||||
})
|
||||
except Exception as e:
|
||||
with metrics_lock:
|
||||
if "error_log" not in metrics:
|
||||
metrics["error_log"] = []
|
||||
if len(metrics["error_log"]) < 100:
|
||||
metrics["error_log"].append(f"vram_monitor: {e}")
|
||||
time.sleep(0.5)
|
||||
|
||||
|
||||
def main():
|
||||
"""Execute 10,000 parallel instance stress test with 100+ program variants."""
|
||||
print("\n" + "="*80)
|
||||
print("🔥 EXTREME STRESS TEST: 10,000 Parallel Instances × 120 Program Variants")
|
||||
print("="*80)
|
||||
print(f"Start Time: {datetime.now().isoformat()}")
|
||||
print(f"Duration: {DURATION_SECS} seconds (10 minutes)")
|
||||
print(f"Max Workers: {MAX_WORKERS}")
|
||||
print()
|
||||
|
||||
# Generate program variants
|
||||
print("[1/3] Generating 120 program variants...")
|
||||
variants = generate_program_variants()
|
||||
print(f"✓ Generated {len(variants)} unique program variants")
|
||||
print()
|
||||
|
||||
# Start VRAM monitoring thread
|
||||
print("[2/3] Starting system monitoring...")
|
||||
vram_monitor = threading.Thread(target=monitor_vram, daemon=True)
|
||||
vram_monitor.start()
|
||||
print("✓ VRAM monitoring started")
|
||||
print()
|
||||
|
||||
# Launch 10,000 parallel instances
|
||||
print(f"[3/3] Launching {INSTANCES} parallel instances...")
|
||||
print(f"Each instance randomly selects from {len(variants)} program variants")
|
||||
print()
|
||||
|
||||
start_time = time.time()
|
||||
execution_count = 0
|
||||
|
||||
with concurrent.futures.ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
|
||||
futures_to_instance = {}
|
||||
|
||||
# Submit initial batch
|
||||
for i in range(INSTANCES):
|
||||
program = random.choice(variants)
|
||||
future = executor.submit(run_stress_instance, i, program)
|
||||
futures_to_instance[future] = i
|
||||
|
||||
# Process completions until timeout
|
||||
while time.time() - start_time < DURATION_SECS:
|
||||
done, _ = concurrent.futures.wait(
|
||||
futures_to_instance.keys(),
|
||||
timeout=1.0,
|
||||
return_when=concurrent.futures.FIRST_COMPLETED
|
||||
)
|
||||
|
||||
for future in done:
|
||||
try:
|
||||
result = future.result()
|
||||
execution_count += 1
|
||||
|
||||
# Print progress every 500 executions
|
||||
if execution_count % 500 == 0:
|
||||
elapsed = time.time() - start_time
|
||||
rate = execution_count / elapsed
|
||||
print(f" ⚡ {execution_count} executions | "
|
||||
f"{rate:.1f} exec/sec | "
|
||||
f"{elapsed:.1f}s elapsed | "
|
||||
f"{metrics['guardrail_triggers']} guardrail triggers")
|
||||
|
||||
except Exception as e:
|
||||
print(f" ✗ Execution failed: {e}")
|
||||
|
||||
del futures_to_instance[future]
|
||||
|
||||
# Submit new instance if time remains
|
||||
if time.time() - start_time < DURATION_SECS:
|
||||
program = random.choice(variants)
|
||||
new_future = executor.submit(run_stress_instance, execution_count, program)
|
||||
futures_to_instance[new_future] = execution_count
|
||||
|
||||
# Check time
|
||||
if time.time() - start_time >= DURATION_SECS:
|
||||
break
|
||||
|
||||
# Cancel remaining futures
|
||||
for future in futures_to_instance.keys():
|
||||
future.cancel()
|
||||
|
||||
metrics["end_time"] = time.time()
|
||||
total_elapsed = metrics["end_time"] - metrics["start_time"]
|
||||
|
||||
# Print results
|
||||
print()
|
||||
print("="*80)
|
||||
print("📊 STRESS TEST RESULTS")
|
||||
print("="*80)
|
||||
print()
|
||||
print(f"Duration: {total_elapsed:.1f} seconds")
|
||||
print(f"Total Executions: {metrics['total_executions']}")
|
||||
print(f"Successful: {metrics['successful_executions']}")
|
||||
print(f"Failed: {metrics['failed_executions']}")
|
||||
print(f"Success Rate: {100 * metrics['successful_executions'] / max(1, metrics['total_executions']):.1f}%")
|
||||
print()
|
||||
print(f"⚠️ Guardrail Triggers: {metrics['guardrail_triggers']}")
|
||||
print(f"Throughput: {metrics['total_executions'] / total_elapsed:.1f} executions/second")
|
||||
print()
|
||||
|
||||
# Variant distribution
|
||||
print("Program Variant Distribution (top 15):")
|
||||
sorted_variants = sorted(metrics["variant_counters"].items(), key=lambda x: x[1], reverse=True)
|
||||
for variant, count in sorted_variants[:15]:
|
||||
print(f" {variant}: {count} executions")
|
||||
print()
|
||||
|
||||
# VRAM analysis
|
||||
if metrics["vram_peaks"]:
|
||||
vram_percents = [v["percent"] for v in metrics["vram_peaks"]]
|
||||
vram_gbs = [v["used_gb"] for v in metrics["vram_peaks"]]
|
||||
print("Memory Usage:")
|
||||
print(f" Peak: {max(vram_percents):.1f}% ({max(vram_gbs):.2f} GB)")
|
||||
print(f" Average: {sum(vram_percents)/len(vram_percents):.1f}%")
|
||||
print()
|
||||
|
||||
# Error summary
|
||||
if metrics["error_log"]:
|
||||
print(f"Sample Errors ({len(metrics['error_log'])} total):")
|
||||
for error in metrics["error_log"][:5]:
|
||||
print(f" Instance {error['instance']} ({error['program']}): {error['error']}")
|
||||
print()
|
||||
|
||||
print("="*80)
|
||||
print(f"✅ STRESS TEST COMPLETE")
|
||||
print(f"End Time: {datetime.now().isoformat()}")
|
||||
print("="*80)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user