Performance Profiling

#!/usr/bin/env python3
"""
Bottleneck Detector - Identify performance bottlenecks and recommend optimizations.
"""
import argparse
import json
import sys
from typing import Dict, List, Optional


def load_analysis_results(timing_path: str, scaling_path: Optional[str] = None,
                          memory_path: Optional[str] = None) -> Dict:
    """
    Load analysis results from JSON files.
    
    Args:
        timing_path: Path to timing analysis JSON
        scaling_path: Path to scaling analysis JSON (optional)
        memory_path: Path to memory profile JSON (optional)
    
    Returns:
        Combined analysis data
    """
    results = {}
    
    # Load timing data (required)
    try:
        with open(timing_path, 'r', encoding='utf-8') as f:
            results['timing'] = json.load(f)
    except FileNotFoundError:
        raise FileNotFoundError(f"Timing analysis file not found: {timing_path}")
    except json.JSONDecodeError as e:
        raise ValueError(f"Invalid timing JSON: {e}")
    
    # Load scaling data (optional)
    if scaling_path:
        try:
            with open(scaling_path, 'r', encoding='utf-8') as f:
                results['scaling'] = json.load(f)
        except FileNotFoundError:
            print(f"Warning: Scaling file not found: {scaling_path}", file=sys.stderr)
        except json.JSONDecodeError as e:
            print(f"Warning: Invalid scaling JSON: {e}", file=sys.stderr)
    
    # Load memory data (optional)
    if memory_path:
        try:
            with open(memory_path, 'r', encoding='utf-8') as f:
                results['memory'] = json.load(f)
        except FileNotFoundError:
            print(f"Warning: Memory file not found: {memory_path}", file=sys.stderr)
        except json.JSONDecodeError as e:
            print(f"Warning: Invalid memory JSON: {e}", file=sys.stderr)
    
    return results


def detect_timing_bottlenecks(timing_data: Dict, threshold: float = 50.0) -> List[Dict]:
    """
    Detect timing bottlenecks from timing analysis.
    
    Args:
        timing_data: Timing analysis results
        threshold: Percentage threshold for bottleneck (default: 50%)
    
    Returns:
        List of bottleneck dictionaries
    """
    bottlenecks = []
    
    if 'timing_data' not in timing_data:
        return bottlenecks
    
    phases = timing_data['timing_data'].get('phases', [])
    
    for phase in phases:
        percentage = phase.get('percentage', 0)
        if percentage > threshold:
            severity = 'high' if percentage > 70 else 'medium'
            bottlenecks.append({
                'type': 'timing',
                'phase': phase['name'],
                'severity': severity,
                'metric': 'percentage',
                'value': percentage,
                'threshold': threshold
            })
    
    return bottlenecks


def detect_scaling_bottlenecks(scaling_data: Dict, threshold: float = 0.70) -> List[Dict]:
    """
    Detect scaling bottlenecks from scaling analysis.
    
    Args:
        scaling_data: Scaling analysis results
        threshold: Efficiency threshold (default: 0.70)
    
    Returns:
        List of bottleneck dictionaries
    """
    bottlenecks = []
    
    if 'scaling_analysis' not in scaling_data:
        return bottlenecks
    
    analysis = scaling_data['scaling_analysis']
    avg_efficiency = analysis.get('average_efficiency', 1.0)
    
    if avg_efficiency < threshold:
        bottlenecks.append({
            'type': 'scaling',
            'phase': 'parallel_efficiency',
            'severity': 'high' if avg_efficiency < 0.5 else 'medium',
            'metric': 'efficiency',
            'value': avg_efficiency,
            'threshold': threshold
        })
    
    return bottlenecks


def detect_memory_bottlenecks(memory_data: Dict, threshold: float = 0.80) -> List[Dict]:
    """
    Detect memory bottlenecks from memory profile.
    
    Args:
        memory_data: Memory profile results
        threshold: Memory usage threshold (default: 0.80 = 80%)
    
    Returns:
        List of bottleneck dictionaries
    """
    bottlenecks = []
    
    if 'memory_profile' not in memory_data:
        return bottlenecks
    
    profile = memory_data['memory_profile']
    
    # Check if warnings exist (indicates high memory usage)
    if profile.get('warnings'):
        total_memory = profile.get('total_memory_gb', 0)
        bottlenecks.append({
            'type': 'memory',
            'phase': 'memory_usage',
            'severity': 'high',
            'metric': 'total_memory_gb',
            'value': total_memory,
            'threshold': threshold
        })
    
    return bottlenecks


def generate_recommendations(bottlenecks: List[Dict], timing_data: Optional[Dict] = None) -> List[Dict]:
    """
    Generate optimization recommendations based on bottlenecks.
    
    Args:
        bottlenecks: List of detected bottlenecks
        timing_data: Optional timing data for context
    
    Returns:
        List of recommendation dictionaries
    """
    recommendations = []
    
    if not bottlenecks:
        recommendations.append({
            'priority': 'low',
            'category': 'general',
            'issue': 'No significant bottlenecks detected',
            'strategies': ['Performance appears balanced', 'Consider profiling at larger scale']
        })
        return recommendations
    
    # Process timing bottlenecks
    for bottleneck in bottlenecks:
        if bottleneck['type'] == 'timing':
            phase = bottleneck['phase'].lower()
            
            # Solver-related bottlenecks
            if any(keyword in phase for keyword in ['solve', 'linear', 'iteration', 'cg', 'gmres']):
                recommendations.append({
                    'priority': 'high',
                    'category': 'solver',
                    'issue': f"{bottleneck['phase']} dominates runtime ({bottleneck['value']:.1f}%)",
                    'strategies': [
                        'Use algebraic multigrid (AMG) preconditioner',
                        'Tighten solver tolerance if over-solving',
                        'Consider direct solver for small problems',
                        'Profile matrix assembly vs solve time'
                    ]
                })
            
            # Assembly bottlenecks
            elif any(keyword in phase for keyword in ['assembly', 'assemble', 'build']):
                recommendations.append({
                    'priority': 'high',
                    'category': 'assembly',
                    'issue': f"{bottleneck['phase']} dominates runtime ({bottleneck['value']:.1f}%)",
                    'strategies': [
                        'Cache element matrices if geometry is static',
                        'Use vectorized assembly routines',
                        'Consider matrix-free methods',
                        'Parallelize assembly with coloring'
                    ]
                })
            
            # I/O bottlenecks
            elif any(keyword in phase for keyword in ['io', 'write', 'output', 'save']):
                recommendations.append({
                    'priority': 'medium',
                    'category': 'io',
                    'issue': f"{bottleneck['phase']} dominates runtime ({bottleneck['value']:.1f}%)",
                    'strategies': [
                        'Reduce output frequency',
                        'Use parallel I/O (HDF5, MPI-IO)',
                        'Write to fast scratch storage',
                        'Compress output data'
                    ]
                })
            
            # Generic timing bottleneck
            else:
                recommendations.append({
                    'priority': 'medium',
                    'category': 'general',
                    'issue': f"{bottleneck['phase']} dominates runtime ({bottleneck['value']:.1f}%)",
                    'strategies': [
                        'Profile this phase in detail',
                        'Look for algorithmic improvements',
                        'Consider parallelization opportunities'
                    ]
                })
        
        # Process scaling bottlenecks
        elif bottleneck['type'] == 'scaling':
            recommendations.append({
                'priority': 'high',
                'category': 'parallel',
                'issue': f"Poor parallel efficiency ({bottleneck['value']:.2f})",
                'strategies': [
                    'Investigate communication overhead',
                    'Check for load imbalance',
                    'Reduce synchronization points',
                    'Use asynchronous communication',
                    'Consider hybrid MPI+OpenMP'
                ]
            })
        
        # Process memory bottlenecks
        elif bottleneck['type'] == 'memory':
            recommendations.append({
                'priority': 'high',
                'category': 'memory',
                'issue': f"High memory usage ({bottleneck['value']:.2f} GB)",
                'strategies': [
                    'Reduce mesh resolution',
                    'Use iterative solver (lower memory than direct)',
                    'Enable out-of-core computation',
                    'Increase number of processors',
                    'Use single precision where appropriate'
                ]
            })
    
    return recommendations


def main():
    parser = argparse.ArgumentParser(
        description='Identify performance bottlenecks and recommend optimizations'
    )
    parser.add_argument('--timing', required=True, help='Path to timing analysis JSON')
    parser.add_argument('--scaling', help='Path to scaling analysis JSON (optional)')
    parser.add_argument('--memory', help='Path to memory profile JSON (optional)')
    parser.add_argument('--json', action='store_true', help='Output in JSON format')
    
    args = parser.parse_args()
    
    try:
        # Load analysis results
        results = load_analysis_results(args.timing, args.scaling, args.memory)
        
        # Detect bottlenecks
        bottlenecks = []
        
        if 'timing' in results:
            bottlenecks.extend(detect_timing_bottlenecks(results['timing']))
        
        if 'scaling' in results:
            bottlenecks.extend(detect_scaling_bottlenecks(results['scaling']))
        
        if 'memory' in results:
            bottlenecks.extend(detect_memory_bottlenecks(results['memory']))
        
        # Generate recommendations
        recommendations = generate_recommendations(bottlenecks, results.get('timing'))
        
        # Format output
        if args.json:
            output = {
                'inputs': {
                    'timing_file': args.timing,
                    'scaling_file': args.scaling,
                    'memory_file': args.memory
                },
                'results': {
                    'bottlenecks': bottlenecks,
                    'recommendations': recommendations
                }
            }
            print(json.dumps(output, indent=2))
        else:
            print(f"Bottleneck Analysis")
            print(f"=" * 60)
            
            if bottlenecks:
                print(f"\nDetected Bottlenecks:")
                for bottleneck in bottlenecks:
                    print(f"  [{bottleneck['severity'].upper()}] {bottleneck['phase']}: "
                          f"{bottleneck['metric']} = {bottleneck['value']:.2f}")
            else:
                print("\nNo significant bottlenecks detected")
            
            print(f"\nRecommendations:")
            for rec in recommendations:
                print(f"\n  [{rec['priority'].upper()}] {rec['category'].upper()}")
                print(f"  Issue: {rec['issue']}")
                print(f"  Strategies:")
                for strategy in rec['strategies']:
                    print(f"    - {strategy}")
    
    except (FileNotFoundError, ValueError) as e:
        if args.json:
            print(json.dumps({'error': str(e)}))
        else:
            print(f"Error: {e}", file=sys.stderr)
        sys.exit(1)
    except Exception as e:
        if args.json:
            print(json.dumps({'error': f'Unexpected error: {e}'}))
        else:
            print(f"Unexpected error: {e}", file=sys.stderr)
        sys.exit(3)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
Memory Profiler - Estimate memory requirements from simulation parameters.
"""
import argparse
import json
import sys
from typing import Dict, List, Optional


def load_parameters(path: str) -> Dict:
    """
    Load simulation parameters from JSON file.
    
    Args:
        path: Path to JSON file with parameters
    
    Returns:
        Parameter dictionary
    """
    try:
        with open(path, 'r', encoding='utf-8') as f:
            params = json.load(f)
        
        # Validate required fields
        missing = []
        if 'mesh' not in params:
            missing.append('mesh')
        if 'fields' not in params:
            missing.append('fields')
        
        if missing:
            raise ValueError(f"Missing required parameters: {', '.join(missing)}")
        
        return params
    
    except FileNotFoundError:
        raise FileNotFoundError(f"Parameters file not found: {path}")
    except json.JSONDecodeError as e:
        raise ValueError(f"Invalid JSON format: {e}")


def estimate_field_memory(mesh: Dict, fields: Dict) -> float:
    """
    Estimate memory for field variables.

    Args:
        mesh: Mesh parameters (nx, ny, nz)
        fields: Field definitions

    Returns:
        Memory in GB
    """
    # Calculate total mesh points
    nx = mesh.get('nx', 1)
    ny = mesh.get('ny', 1)
    nz = mesh.get('nz', 1)
    # Validate mesh dimensions
    for name, val in [('nx', nx), ('ny', ny), ('nz', nz)]:
        if not isinstance(val, int) or val <= 0:
            raise ValueError(f"Mesh dimension '{name}' must be a positive integer, got {val}")
    mesh_points = nx * ny * nz

    # Calculate memory for all fields
    total_bytes = 0
    for field_name, field_spec in fields.items():
        components = field_spec.get('components', 1)
        bytes_per_value = field_spec.get('bytes_per_value', 8)  # default: double precision
        if not isinstance(components, int) or components <= 0:
            raise ValueError(f"Field '{field_name}' components must be a positive integer, got {components}")
        if not isinstance(bytes_per_value, (int, float)) or bytes_per_value <= 0:
            raise ValueError(f"Field '{field_name}' bytes_per_value must be positive, got {bytes_per_value}")
        total_bytes += mesh_points * components * bytes_per_value
    
    # Convert to GB
    return total_bytes / (1024 ** 3)


def estimate_solver_memory(mesh: Dict, solver: Dict) -> float:
    """
    Estimate memory for solver workspace.
    
    Args:
        mesh: Mesh parameters
        solver: Solver configuration
    
    Returns:
        Memory in GB
    """
    # Calculate total mesh points
    nx = mesh.get('nx', 1)
    ny = mesh.get('ny', 1)
    nz = mesh.get('nz', 1)
    mesh_points = nx * ny * nz
    
    # Get workspace multiplier based on solver type
    solver_type = solver.get('type', 'iterative')
    workspace_multiplier = solver.get('workspace_multiplier', 5)
    
    # Estimate workspace (typically several vectors of size mesh_points)
    bytes_per_value = 8  # double precision
    workspace_bytes = mesh_points * workspace_multiplier * bytes_per_value
    
    # Convert to GB
    return workspace_bytes / (1024 ** 3)


def compute_total_memory(params: Dict, available_gb: Optional[float] = None) -> Dict:
    """
    Compute total memory requirements.
    
    Args:
        params: Simulation parameters
        available_gb: Available system memory (optional)
    
    Returns:
        Memory profile dictionary
    """
    mesh = params['mesh']
    fields = params['fields']
    solver = params.get('solver', {'type': 'iterative', 'workspace_multiplier': 5})
    processors = params.get('processors', 1)
    if not isinstance(processors, int) or processors <= 0:
        raise ValueError(f"processors must be a positive integer, got {processors}")
    
    # Calculate mesh points
    nx = mesh.get('nx', 1)
    ny = mesh.get('ny', 1)
    nz = mesh.get('nz', 1)
    mesh_points = nx * ny * nz
    
    # Estimate memory components
    field_memory_gb = estimate_field_memory(mesh, fields)
    solver_workspace_gb = estimate_solver_memory(mesh, solver)
    total_memory_gb = field_memory_gb + solver_workspace_gb
    per_process_gb = total_memory_gb / processors
    
    # Generate warnings
    warnings = []
    if available_gb is not None:
        if total_memory_gb > available_gb:
            warnings.append(f"Total memory ({total_memory_gb:.2f} GB) exceeds available memory ({available_gb:.2f} GB)")
        elif total_memory_gb > 0.8 * available_gb:
            warnings.append(f"Memory usage ({total_memory_gb:.2f} GB) is high (>80% of available {available_gb:.2f} GB)")
    
    return {
        'mesh_points': mesh_points,
        'field_memory_gb': field_memory_gb,
        'solver_workspace_gb': solver_workspace_gb,
        'total_memory_gb': total_memory_gb,
        'per_process_gb': per_process_gb,
        'warnings': warnings
    }


def main():
    parser = argparse.ArgumentParser(
        description='Estimate memory requirements from simulation parameters'
    )
    parser.add_argument('--params', required=True, help='Path to JSON file with simulation parameters')
    parser.add_argument('--available-gb', type=float, help='Available system memory in GB')
    parser.add_argument('--json', action='store_true', help='Output in JSON format')
    
    args = parser.parse_args()
    
    try:
        # Load parameters
        params = load_parameters(args.params)
        
        # Compute memory profile
        profile = compute_total_memory(params, args.available_gb)
        
        # Format output
        if args.json:
            output = {
                'inputs': {
                    'params_file': args.params,
                    'available_gb': args.available_gb
                },
                'results': profile
            }
            print(json.dumps(output, indent=2))
        else:
            print(f"Memory Profile")
            print(f"=" * 60)
            print(f"Mesh points: {profile['mesh_points']:,}")
            print(f"Field memory: {profile['field_memory_gb']:.3f} GB")
            print(f"Solver workspace: {profile['solver_workspace_gb']:.3f} GB")
            print(f"Total memory: {profile['total_memory_gb']:.3f} GB")
            print(f"Per-process memory: {profile['per_process_gb']:.3f} GB")
            
            if profile['warnings']:
                print(f"\nWarnings:")
                for warning in profile['warnings']:
                    print(f"  - {warning}")
    
    except (FileNotFoundError, ValueError) as e:
        if args.json:
            print(json.dumps({'error': str(e)}))
        else:
            print(f"Error: {e}", file=sys.stderr)
        sys.exit(1)
    except Exception as e:
        if args.json:
            print(json.dumps({'error': f'Unexpected error: {e}'}))
        else:
            print(f"Unexpected error: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
Scaling Analyzer - Analyze strong and weak scaling from multi-run data.
"""
import argparse
import json
import sys
from typing import Dict, List, Optional


def load_scaling_data(path: str) -> List[Dict]:
    """
    Load scaling data from JSON file.
    
    Args:
        path: Path to JSON file with scaling data
    
    Returns:
        List of run configurations
    """
    try:
        with open(path, 'r', encoding='utf-8') as f:
            data = json.load(f)
        
        if 'runs' not in data:
            raise ValueError("JSON must contain 'runs' array")
        
        runs = data['runs']
        
        if len(runs) < 2:
            raise ValueError("At least 2 runs required for scaling analysis")
        
        # Validate required fields
        for i, run in enumerate(runs):
            if 'processors' not in run:
                raise ValueError(f"Run {i} missing 'processors' field")
            if 'time' not in run:
                raise ValueError(f"Run {i} missing 'time' field")
            if run['time'] <= 0:
                raise ValueError(f"Run {i} has invalid time: {run['time']}")
            if run['processors'] <= 0:
                raise ValueError(f"Run {i} has invalid processor count: {run['processors']}")
        
        return runs
    
    except FileNotFoundError:
        raise FileNotFoundError(f"Scaling data file not found: {path}")
    except json.JSONDecodeError as e:
        raise ValueError(f"Invalid JSON format: {e}")


def compute_strong_scaling(runs: List[Dict]) -> Dict:
    """
    Compute strong scaling efficiency (fixed problem size, varying processors).
    
    Args:
        runs: List of run configurations
    
    Returns:
        Dictionary with scaling analysis results
    """
    # Sort by processor count
    sorted_runs = sorted(runs, key=lambda x: x['processors'])
    
    # Use smallest processor count as baseline
    baseline = sorted_runs[0]
    baseline_time = baseline['time']
    baseline_procs = baseline['processors']
    
    results = []
    for run in sorted_runs:
        procs = run['processors']
        time = run['time']
        
        # Speedup = T_baseline / T_N
        speedup = baseline_time / time
        
        # Efficiency = Speedup / (N / N_baseline) = T_baseline / (N * T_N / N_baseline)
        efficiency = speedup / (procs / baseline_procs)
        
        results.append({
            'processors': procs,
            'time': time,
            'speedup': speedup,
            'efficiency': efficiency
        })
    
    # Find efficiency threshold (first point where efficiency < 0.70)
    threshold_procs = None
    for result in results:
        if result['efficiency'] < 0.70:
            threshold_procs = result['processors']
            break
    
    # Calculate average efficiency
    avg_efficiency = sum(r['efficiency'] for r in results) / len(results)
    
    return {
        'type': 'strong',
        'baseline': {
            'processors': baseline_procs,
            'time': baseline_time
        },
        'results': results,
        'efficiency_threshold_processors': threshold_procs,
        'average_efficiency': avg_efficiency
    }


def compute_weak_scaling(runs: List[Dict]) -> Dict:
    """
    Compute weak scaling efficiency (constant work per processor, varying processors).
    
    Args:
        runs: List of run configurations
    
    Returns:
        Dictionary with scaling analysis results
    """
    # Sort by processor count
    sorted_runs = sorted(runs, key=lambda x: x['processors'])
    
    # Use smallest processor count as baseline
    baseline = sorted_runs[0]
    baseline_time = baseline['time']
    baseline_procs = baseline['processors']
    
    results = []
    for run in sorted_runs:
        procs = run['processors']
        time = run['time']
        
        # For weak scaling, efficiency = T_baseline / T_N
        efficiency = baseline_time / time
        
        # Speedup is not meaningful for weak scaling (problem size changes)
        speedup = efficiency * (procs / baseline_procs)
        
        results.append({
            'processors': procs,
            'time': time,
            'speedup': speedup,
            'efficiency': efficiency
        })
    
    # Find efficiency threshold
    threshold_procs = None
    for result in results:
        if result['efficiency'] < 0.70:
            threshold_procs = result['processors']
            break
    
    # Calculate average efficiency
    avg_efficiency = sum(r['efficiency'] for r in results) / len(results)
    
    return {
        'type': 'weak',
        'baseline': {
            'processors': baseline_procs,
            'time': baseline_time
        },
        'results': results,
        'efficiency_threshold_processors': threshold_procs,
        'average_efficiency': avg_efficiency
    }


def main():
    parser = argparse.ArgumentParser(
        description='Analyze strong and weak scaling from multi-run data'
    )
    parser.add_argument('--data', required=True, help='Path to JSON file with scaling data')
    parser.add_argument('--type', required=True, choices=['strong', 'weak'],
                       help='Scaling type: strong or weak')
    parser.add_argument('--json', action='store_true', help='Output in JSON format')
    
    args = parser.parse_args()
    
    try:
        # Load scaling data
        runs = load_scaling_data(args.data)
        
        # Compute scaling analysis
        if args.type == 'strong':
            analysis = compute_strong_scaling(runs)
        else:
            analysis = compute_weak_scaling(runs)
        
        # Format output
        if args.json:
            output = {
                'inputs': {
                    'data_file': args.data,
                    'scaling_type': args.type
                },
                'results': analysis
            }
            print(json.dumps(output, indent=2))
        else:
            print(f"{args.type.capitalize()} Scaling Analysis")
            print(f"=" * 60)
            print(f"Baseline: {analysis['baseline']['processors']} processors, "
                  f"{analysis['baseline']['time']:.2f}s\n")
            
            print(f"{'Procs':<8} {'Time (s)':<12} {'Speedup':<12} {'Efficiency':<12}")
            print("-" * 60)
            for result in analysis['results']:
                print(f"{result['processors']:<8} {result['time']:<12.2f} "
                      f"{result['speedup']:<12.2f} {result['efficiency']:<12.3f}")
            
            print(f"\nAverage efficiency: {analysis['average_efficiency']:.3f}")
            if analysis['efficiency_threshold_processors']:
                print(f"Efficiency drops below 0.70 at {analysis['efficiency_threshold_processors']} processors")
            else:
                print("Efficiency remains above 0.70 for all configurations")
    
    except (FileNotFoundError, ValueError) as e:
        if args.json:
            print(json.dumps({'error': str(e)}))
        else:
            print(f"Error: {e}", file=sys.stderr)
        sys.exit(1)
    except Exception as e:
        if args.json:
            print(json.dumps({'error': f'Unexpected error: {e}'}))
        else:
            print(f"Unexpected error: {e}", file=sys.stderr)
        sys.exit(3)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
Timing Analyzer - Extract and analyze timing information from simulation logs.
"""
import argparse
import json
import re
import sys
from typing import Dict, List, Optional, Tuple


def parse_timing_log(log_path: str, pattern: Optional[str] = None) -> List[Tuple[str, float]]:
    """
    Parse simulation log file and extract timing entries.
    
    Args:
        log_path: Path to log file
        pattern: Custom regex pattern (optional)
    
    Returns:
        List of (phase_name, time_seconds) tuples
    """
    # Default patterns for common log formats
    default_patterns = [
        r'Phase:\s*([^,]+),\s*Time:\s*([\d.]+)s',
        r'(\w+(?:\s+\w+)*)\s+took\s+([\d.]+)\s*s',
        r'\[([^\]]+)\]\s*:\s*([\d.]+)\s*s',
        r'Time\s+for\s+([^:]+):\s*([\d.]+)',
    ]
    
    patterns_to_try = [pattern] if pattern else default_patterns
    
    entries = []
    malformed_count = 0
    
    try:
        with open(log_path, 'r', encoding='utf-8') as f:
            for line in f:
                line = line.strip()
                if not line:
                    continue
                
                matched = False
                for pat in patterns_to_try:
                    match = re.search(pat, line)
                    if match:
                        try:
                            phase = match.group(1).strip()
                            time_val = float(match.group(2))
                            if time_val >= 0:
                                entries.append((phase, time_val))
                                matched = True
                                break
                        except (ValueError, IndexError):
                            malformed_count += 1
                
                if not matched and any(keyword in line.lower() for keyword in ['time', 'phase', 'took']):
                    malformed_count += 1
    
    except FileNotFoundError:
        raise FileNotFoundError(f"Log file not found: {log_path}")
    except Exception as e:
        raise ValueError(f"Error reading log file: {e}")
    
    if malformed_count > 0:
        print(f"Warning: Skipped {malformed_count} malformed timing entries", file=sys.stderr)
    
    return entries


def aggregate_timings(entries: List[Tuple[str, float]]) -> Dict[str, Dict[str, float]]:
    """
    Aggregate timing entries by phase.
    
    Args:
        entries: List of (phase_name, time_seconds) tuples
    
    Returns:
        Dictionary mapping phase names to aggregated statistics
    """
    if not entries:
        return {}
    
    phase_times: Dict[str, List[float]] = {}
    for phase, time_val in entries:
        if phase not in phase_times:
            phase_times[phase] = []
        phase_times[phase].append(time_val)
    
    total_time = sum(time_val for _, time_val in entries)
    
    aggregated = {}
    for phase, times in phase_times.items():
        aggregated[phase] = {
            'total_time': sum(times),
            'count': len(times),
            'mean_time': sum(times) / len(times),
            'min_time': min(times),
            'max_time': max(times),
            'percentage': (sum(times) / total_time * 100) if total_time > 0 else 0.0
        }
    
    return aggregated


def identify_slowest_phases(aggregated: Dict[str, Dict[str, float]], top_n: int = 5) -> List[str]:
    """
    Identify the slowest computational phases.
    
    Args:
        aggregated: Aggregated timing data
        top_n: Number of slowest phases to return
    
    Returns:
        List of phase names sorted by total time (descending)
    """
    if not aggregated:
        return []
    
    sorted_phases = sorted(aggregated.items(), key=lambda x: x[1]['total_time'], reverse=True)
    return [phase for phase, _ in sorted_phases[:top_n]]


def main():
    parser = argparse.ArgumentParser(
        description='Extract and analyze timing information from simulation logs'
    )
    parser.add_argument('--log', required=True, help='Path to simulation log file')
    parser.add_argument('--pattern', help='Custom regex pattern for timing entries')
    parser.add_argument('--json', action='store_true', help='Output in JSON format')
    
    args = parser.parse_args()
    
    try:
        # Parse log file
        entries = parse_timing_log(args.log, args.pattern)
        
        # Aggregate timings
        aggregated = aggregate_timings(entries)
        
        # Identify slowest phases
        slowest = identify_slowest_phases(aggregated)
        
        # Calculate total time
        total_time = sum(data['total_time'] for data in aggregated.values())
        
        # Format output
        if args.json:
            output = {
                'inputs': {
                    'log_file': args.log,
                    'pattern': args.pattern or 'default'
                },
                'results': {
                    'phases': [
                        {
                            'name': phase,
                            **aggregated[phase]
                        }
                        for phase in aggregated
                    ],
                    'total_time': total_time,
                    'slowest_phase': slowest[0] if slowest else None
                }
            }
            print(json.dumps(output, indent=2))
        else:
            print(f"Timing Analysis Results")
            print(f"=" * 60)
            print(f"Total time: {total_time:.2f}s\n")
            
            if aggregated:
                print(f"{'Phase':<30} {'Total (s)':<12} {'Count':<8} {'Mean (s)':<12} {'%':<8}")
                print("-" * 60)
                for phase in slowest:
                    data = aggregated[phase]
                    print(f"{phase:<30} {data['total_time']:<12.2f} {data['count']:<8} "
                          f"{data['mean_time']:<12.2f} {data['percentage']:<8.1f}")
            else:
                print("No timing data found in log file")
    
    except (FileNotFoundError, ValueError) as e:
        if args.json:
            print(json.dumps({'error': str(e)}))
        else:
            print(f"Error: {e}", file=sys.stderr)
        sys.exit(1)
    except Exception as e:
        if args.json:
            print(json.dumps({'error': f'Unexpected error: {e}'}))
        else:
            print(f"Unexpected error: {e}", file=sys.stderr)
        sys.exit(3)


if __name__ == '__main__':
    main()