#!/usr/bin/env python3
"""
Automated Massif analysis script for CI/CD integration
"""
import subprocess
import sys
import glob
import os
from datetime import datetime

def run_massif_analysis(executable, args=None):
    """Run Massif profiling on an executable"""
    cmd = [
        'valgrind', '--tool=massif',
        '--heap=yes',
        '--detailed-freq=1',
        '--threshold=0.1',
        '--massif-out-file=massif.out.%p',
        executable
    ]
    
    if args:
        cmd.extend(args)
    
    print(f"Running: {' '.join(cmd)}")
    result = subprocess.run(cmd, capture_output=True, text=True)
    
    return result.returncode == 0

def analyze_massif_output():
    """Analyze Massif output files"""
    massif_files = glob.glob('massif.out.*')
    
    for massif_file in massif_files:
        print(f"\nAnalyzing {massif_file}:")
        
        # Generate report
        cmd = ['ms_print', massif_file]
        result = subprocess.run(cmd, capture_output=True, text=True)
        
        if result.returncode == 0:
            # Save detailed report
            report_file = f"memory_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
            with open(report_file, 'w') as f:
                f.write(result.stdout)
            
            # Extract peak information
            lines = result.stdout.split('\n')
            for i, line in enumerate(lines):
                if 'peak' in line.lower():
                    print(f"Peak memory: {line}")
                    # Print context around peak
                    for j in range(max(0, i-2), min(len(lines), i+5)):
                        print(f"  {lines[j]}")
                    break
        
        # Cleanup
        os.remove(massif_file)

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Usage: massif_analyzer.py <executable> [args...]")
        sys.exit(1)
    
    executable = sys.argv[1]
    args = sys.argv[2:] if len(sys.argv) > 2 else None
    
    if run_massif_analysis(executable, args):
        analyze_massif_output()
    else:
        print("Massif analysis failed")
        sys.exit(1)

#!/usr/bin/env python3
"""
Memory regression testing with Massif
"""
import subprocess
import json
import sys

def extract_peak_memory(massif_file):
    """Extract peak memory usage from Massif output"""
    cmd = ['ms_print', massif_file]
    result = subprocess.run(cmd, capture_output=True, text=True)
    
    for line in result.stdout.split('\n'):
        if 'peak' in line.lower() and 'MB' in line:
            # Extract numeric value
            import re
            match = re.search(r'(\d+\.?\d*)\s*MB', line)
            if match:
                return float(match.group(1))
    return 0.0

def run_memory_regression_test(baseline_mb, current_executable):
    """Compare current memory usage against baseline"""
    # Run Massif on current version
    cmd = ['valgrind', '--tool=massif', '--massif-out-file=current.massif', current_executable]
    subprocess.run(cmd, capture_output=True)
    
    # Extract current memory usage
    current_mb = extract_peak_memory('current.massif')
    
    # Calculate regression
    regression_percent = ((current_mb - baseline_mb) / baseline_mb) * 100
    
    print(f"Baseline memory: {baseline_mb:.1f} MB")
    print(f"Current memory:  {current_mb:.1f} MB")
    print(f"Regression:      {regression_percent:+.1f}%")
    
    # Fail if regression exceeds 10%
    if regression_percent > 10.0:
        print("FAIL: Memory regression exceeds 10% threshold")
        return False
    
    return True

if __name__ == "__main__":
    baseline_mb = float(sys.argv[1])
    executable = sys.argv[2]
    
    success = run_memory_regression_test(baseline_mb, executable)
    sys.exit(0 if success else 1)

#!/usr/bin/env python3
"""
Advanced Massif output parser
"""
import re
import matplotlib.pyplot as plt
from datetime import datetime

class MassifAnalyzer:
    def __init__(self, massif_file):
        self.massif_file = massif_file
        self.snapshots = []
        self.peak_snapshot = None
        self.parse_massif_output()
    
    def parse_massif_output(self):
        """Parse ms_print output"""
        with open(self.massif_file, 'r') as f:
            content = f.read()
        
        # Extract snapshot data
        snapshot_pattern = r'^\s*(\d+)\s+(\d+\.?\d*)\s+(\d+,?\d*)\s+(\d+,?\d*)\s+(\d+,?\d*)\s+(\d+,?\d*)$'
        
        for line in content.split('\n'):
            match = re.match(snapshot_pattern, line)
            if match:
                snapshot = {
                    'number': int(match.group(1)),
                    'time': float(match.group(2)),
                    'total': int(match.group(3).replace(',', '')),
                    'useful_heap': int(match.group(4).replace(',', '')),
                    'extra_heap': int(match.group(5).replace(',', '')),
                    'stacks': int(match.group(6).replace(',', ''))
                }
                self.snapshots.append(snapshot)
                
                # Check if this is peak
                if '(peak)' in line:
                    self.peak_snapshot = snapshot
    
    def plot_memory_timeline(self, output_file='memory_timeline.png'):
        """Generate memory usage timeline plot"""
        times = [s['time'] for s in self.snapshots]
        memory_mb = [s['total'] / (1024*1024) for s in self.snapshots]
        
        plt.figure(figsize=(12, 6))
        plt.plot(times, memory_mb, 'b-', linewidth=2, label='Total Memory')
        
        if self.peak_snapshot:
            peak_time = self.peak_snapshot['time']
            peak_memory = self.peak_snapshot['total'] / (1024*1024)
            plt.plot(peak_time, peak_memory, 'ro', markersize=8, label='Peak')
        
        plt.xlabel('Time (seconds)')
        plt.ylabel('Memory Usage (MB)')
        plt.title('Memory Usage Over Time')
        plt.legend()
        plt.grid(True, alpha=0.3)
        plt.savefig(output_file, dpi=150, bbox_inches='tight')
        print(f"Timeline plot saved to {output_file}")
    
    def generate_report(self):
        """Generate comprehensive analysis report"""
        if not self.snapshots:
            return "No snapshots found in Massif output"
        
        total_snapshots = len(self.snapshots)
        max_memory = max(s['total'] for s in self.snapshots)
        avg_memory = sum(s['total'] for s in self.snapshots) / total_snapshots
        
        report = f"""
Massif Analysis Report
=====================
Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}

Summary:
- Total snapshots: {total_snapshots}
- Peak memory: {max_memory / (1024*1024):.1f} MB
- Average memory: {avg_memory / (1024*1024):.1f} MB
- Runtime: {self.snapshots[-1]['time']:.2f} seconds

Peak Memory Details:
"""
        
        if self.peak_snapshot:
            peak = self.peak_snapshot
            report += f"""
- Peak occurred at: {peak['time']:.2f} seconds
- Total memory: {peak['total'] / (1024*1024):.1f} MB
- Useful heap: {peak['useful_heap'] / (1024*1024):.1f} MB
- Extra heap: {peak['extra_heap'] / (1024*1024):.1f} MB
- Overhead: {(peak['extra_heap'] / peak['useful_heap']) * 100:.1f}%
"""
        
        return report

# Usage example
if __name__ == "__main__":
    import sys
    if len(sys.argv) != 2:
        print("Usage: python massif_analyzer.py <ms_print_output_file>")
        sys.exit(1)
    
    analyzer = MassifAnalyzer(sys.argv[1])
    print(analyzer.generate_report())
    analyzer.plot_memory_timeline()