Hotdry.
归档
systems-engineering

GCC O3性能回归诊断工具包：代码分析与自动化测试脚本

提供一套完整的GCC O3性能回归诊断工具，包括自动化基准测试、二进制分析脚本和内存层次结构监控工具。

GCC O3 性能回归诊断工具包

1. 自动化基准测试脚本

1.1 多级别编译对比脚本

#!/bin/bash
# optimize_benchmark.sh - 自动化GCC优化级别对比测试

set -e

# 编译参数配置
SOURCE_FILE="${1:-test_program.c}"
OUTPUT_PREFIX="optimize_test"
OPT_LEVELS=("O0" "O1" "O2" "O3")
OPT_NAMES=("no_opt" "basic_opt" "std_opt" "aggressive_opt")

echo "=== GCC优化级别性能对比测试 ==="
echo "源文件: $SOURCE_FILE"
echo "测试优化级别: ${OPT_LEVELS[@]}"

# 清理之前的编译结果
rm -f ${OUTPUT_PREFIX}_*

# 逐个编译和测试
for i in "${!OPT_LEVELS[@]}"; do
    level="${OPT_LEVELS[$i]}"
    name="${OPT_NAMES[$i]}"
    binary="${OUTPUT_PREFIX}_${name}"
    
    echo -e "\n--- 编译: -$level ---"
    
    # 编译
    if gcc "-$level" -o "$binary" "$SOURCE_FILE" -lm; then
        echo "✓ 编译成功"
        
        # 获取二进制文件信息
        size_info=$(size "$binary" | tail -1)
        echo "代码大小: $size_info"
        
        # 运行性能测试（需要用户自定义测试代码）
        echo "运行基准测试..."
        if [ -f "benchmark_${name}.sh" ]; then
            time_output=$( { time ./benchmark_${name}.sh > /dev/null 2>&1; } 2>&1 )
            echo "执行时间: $time_output"
        fi
        
        # 运行额外的性能指标收集
        if command -v perf &> /dev/null; then
            echo "收集性能指标..."
            perf stat -e cycles,instructions,cache-misses,cache-references,branches,branch-misses \
                     -o "${binary}_perf.txt" ./"$binary" || true
        fi
        
    else
        echo "✗ 编译失败"
        continue
    fi
done

# 生成对比报告
echo -e "\n=== 生成对比报告 ==="
{
    echo "# GCC优化级别性能对比报告"
    echo "生成时间: $(date)"
    echo "源文件: $SOURCE_FILE"
    echo ""
    echo "## 二进制文件大小对比"
    for i in "${!OPT_LEVELS[@]}"; do
        level="${OPT_LEVELS[$i]}"
        name="${OPT_NAMES[$i]}"
        binary="${OUTPUT_PREFIX}_${name}"
        if [ -f "$binary" ]; then
            size_info=$(size "$binary" | tail -1)
            echo "- $level: $size_info"
        fi
    done
} > optimize_report.md

echo "报告已生成: optimize_report.md"

1.2 汇编代码对比分析脚本

#!/usr/bin/env python3
# asm_analyzer.py - GCC汇编代码对比分析工具

import subprocess
import sys
import re
from pathlib import Path

def extract_assembly(source_file, opt_level, output_file):
    """提取指定优化级别的汇编代码"""
    cmd = [
        'gcc', f'-{opt_level}', '-S', 
        '-fverbose-asm', '-fno-asynchronous-unwind-tables',
        '-o', output_file, source_file
    ]
    
    print(f"生成{opt_level}汇编: {' '.join(cmd)}")
    result = subprocess.run(cmd, capture_output=True, text=True)
    
    if result.returncode != 0:
        print(f"汇编生成失败: {result.stderr}")
        return False
    
    return True

def analyze_assembly(file_path):
    """分析汇编文件的关键指标"""
    metrics = {
        'total_lines': 0,
        'instructions': 0,
        'branches': 0,
        'calls': 0,
        'loops': 0,
        'cache_alignment_directives': 0
    }
    
    branch_patterns = [
        r'\bj\w+\s+', r'\bje\b', r'\bjne\b', r'\bjl\b', r'\bjg\b',
        r'\bjle\b', r'\bjge\b', r'\bja\b', r'\bjb\b'
    ]
    
    call_patterns = [r'\bcall\b', r'\bcallq\b']
    loop_patterns = [r'\.L[0-9]+:', r'loop']
    alignment_patterns = [r'\.p2align', r'\.align']
    
    with open(file_path, 'r') as f:
        for line in f:
            metrics['total_lines'] += 1
            
            # 统计指令
            if re.search(r'^\s+[a-zA-Z]', line):
                metrics['instructions'] += 1
            
            # 统计分支
            if any(re.search(pattern, line) for pattern in branch_patterns):
                metrics['branches'] += 1
            
            # 统计函数调用
            if any(re.search(pattern, line) for pattern in call_patterns):
                metrics['calls'] += 1
            
            # 统计循环标签
            if any(re.search(pattern, line) for pattern in loop_patterns):
                metrics['loops'] += 1
            
            # 统计缓存对齐指令
            if any(re.search(pattern, line) for pattern in alignment_patterns):
                metrics['cache_alignment_directives'] += 1
    
    return metrics

def compare_optimizations(source_file, opt_levels=['O1', 'O2', 'O3']):
    """对比不同优化级别的汇编代码"""
    print(f"开始分析: {source_file}")
    
    asm_files = {}
    
    # 生成汇编文件
    for level in opt_levels:
        asm_file = f"{source_file}.{level}.s"
        if extract_assembly(source_file, level, asm_file):
            asm_files[level] = asm_file
    
    if not asm_files:
        print("没有生成汇编文件")
        return
    
    # 分析每个汇编文件
    results = {}
    for level, asm_file in asm_files.items():
        print(f"\n分析{level}汇编: {asm_file}")
        results[level] = analyze_assembly(asm_file)
    
    # 生成对比报告
    print(f"\n{'='*60}")
    print("汇编代码对比分析结果")
    print(f"{'='*60}")
    
    headers = ['指标'] + opt_levels
    print(f"{headers[0]:<20} {' '.join(f'{h:>8}' for h in headers[1:])}")
    print("-" * (20 + 8 * len(opt_levels)))
    
    for metric in ['total_lines', 'instructions', 'branches', 'calls', 'loops', 'cache_alignment_directives']:
        values = [results.get(level, {}).get(metric, 0) for level in opt_levels]
        print(f"{metric.replace('_', ' ').title():<20} {' '.join(f'{v:>8}' for v in values)}")
    
    # 生成详细分析
    with open('assembly_analysis.md', 'w') as f:
        f.write("# GCC汇编代码对比分析报告\n\n")
        f.write(f"源文件: {source_file}\n")
        f.write(f"分析时间: {subprocess.run(['date'], capture_output=True, text=True).stdout.strip()}\n\n")
        
        for level in opt_levels:
            if level in results:
                f.write(f"## {level} 优化级别分析\n\n")
                metrics = results[level]
                for metric, value in metrics.items():
                    f.write(f"- {metric.replace('_', ' ').title()}: {value}\n")
                f.write("\n")

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("用法: python3 asm_analyzer.py <源文件.c> [优化级别...]")
        print("示例: python3 asm_analyzer.py test.c O1 O2 O3")
        sys.exit(1)
    
    source_file = sys.argv[1]
    opt_levels = sys.argv[2:] if len(sys.argv) > 2 else ['O1', 'O2', 'O3']
    
    compare_optimizations(source_file, opt_levels)

2. 内存层次结构监控工具

2.1 缓存行为监控库

/*
 * cache_monitor.h - 缓存行为监控工具
 * 适用于x86和ARM架构的缓存监控
 */

#ifndef CACHE_MONITOR_H
#define CACHE_MONITOR_H

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <time.h>

#ifdef __x86_64__
#include <x86intrin.h>
#define RDTSC_START() __rdtsc()
#define RDTSC_END() __rdtsc()
#elif defined(__aarch64__)
#include <arm_neon.h>
#define RDTSC_START() __rdtsc()
#define RDTSC_END() __rdtsc()
#else
#define RDTSC_START() clock()
#define RDTSC_END() clock()
#endif

// 缓存行大小检测
static inline size_t get_cache_line_size() {
    FILE *f = fopen("/sys/devices/system/cpu/cpu0/cache/index0/coherency_line_size", "r");
    size_t size = 64;  // 默认值
    if (f) {
        fscanf(f, "%zu", &size);
        fclose(f);
    }
    return size;
}

// L1缓存大小检测
static inline size_t get_l1_cache_size() {
    FILE *f = fopen("/sys/devices/system/cpu/cpu0/cache/index0/size", "r");
    size_t size = 32 * 1024;  // 默认32KB
    if (f) {
        char unit;
        int value;
        fscanf(f, "%d%c", &value, &unit);
        if (unit == 'K' || unit == 'k') size = value * 1024;
        else if (unit == 'M' || unit == 'm') size = value * 1024 * 1024;
        fclose(f);
    }
    return size;
}

// 缓存miss率测试
typedef struct {
    size_t cache_line_size;
    size_t l1_cache_size;
    uint64_t total_cycles;
    uint64_t cache_misses;
    double miss_rate;
} cache_metrics_t;

static inline void clear_cache() {
    // 简单的缓存清空策略
    const size_t size = get_l1_cache_size();
    char *buffer = malloc(size);
    for (size_t i = 0; i < size; i += get_cache_line_size()) {
        buffer[i] = (char)(i & 0xFF);
    }
    free(buffer);
}

static cache_metrics_t measure_cache_performance(void (*test_func)(void)) {
    cache_metrics_t metrics = {0};
    
    metrics.cache_line_size = get_cache_line_size();
    metrics.l1_cache_size = get_l1_cache_size();
    
    // 多次测量取平均值
    const int iterations = 100;
    uint64_t total_start, total_end;
    uint64_t cache_misses = 0;
    
    for (int i = 0; i < iterations; i++) {
        clear_cache();
        total_start = RDTSC_START();
        test_func();
        total_end = RDTSC_END();
        metrics.total_cycles += (total_end - total_start);
    }
    
    metrics.total_cycles /= iterations;
    
    return metrics;
}

// 直接映射缓存冲突测试
static void test_direct_mapped_conflicts() {
    const size_t cache_size = 16 * 1024; // 16KB L1缓存
    const size_t line_size = 64;         // 64B缓存行
    
    printf("=== 直接映射缓存冲突测试 ===\n");
    printf("缓存大小: %zu KB\n", cache_size / 1024);
    printf("缓存行大小: %zu B\n", line_size);
    
    // 测试不同步长的访问模式
    for (size_t stride = line_size; stride <= cache_size * 2; stride += line_size) {
        uint64_t start = RDTSC_START();
        
        // 访问足够多的元素来填满缓存
        for (int i = 0; i < (cache_size / stride) * 4; i++) {
            volatile char data[i * stride % (cache_size * 2)];
            data = (char)i;
        }
        
        uint64_t end = RDTSC_END();
        uint64_t cycles = end - start;
        
        printf("步长 %4zu B: %lu 周期\n", stride, cycles);
    }
}

// 缓存局部性测试
static void test_cache_locality() {
    const size_t array_size = 1024 * 1024; // 1MB数组
    int *array = malloc(array_size);
    
    printf("=== 缓存局部性测试 ===\n");
    
    // 顺序访问测试
    uint64_t start = RDTSC_START();
    for (size_t i = 0; i < array_size / sizeof(int); i++) {
        array[i] = i;
    }
    uint64_t sequential_time = RDTSC_END() - start;
    
    // 跳跃访问测试
    start = RDTSC_START();
    for (size_t i = 0; i < array_size / sizeof(int); i += 64) {
        array[i] = i;
    }
    uint64_t stride_time = RDTSC_END() - start;
    
    printf("顺序访问: %lu 周期\n", sequential_time);
    printf("跳跃访问: %lu 周期\n", stride_time);
    printf("性能比率: %.2f\n", (double)stride_time / sequential_time);
    
    free(array);
}

#endif // CACHE_MONITOR_H

2.2 内存访问模式分析工具

/*
 * memory_analyzer.c - 内存访问模式分析
 */

#include "cache_monitor.h"
#include <string.h>

// 测试不同的内存访问模式
void test_memory_patterns() {
    const size_t data_size = 16 * 1024 * 1024; // 16MB数据
    char *data = malloc(data_size);
    
    if (!data) {
        printf("内存分配失败\n");
        return;
    }
    
    printf("\n=== 内存访问模式分析 ===\n");
    
    // 模式1: 顺序访问
    printf("\n1. 顺序访问模式\n");
    uint64_t start = RDTSC_START();
    for (size_t i = 0; i < data_size; i++) {
        data[i] = (char)(i & 0xFF);
    }
    uint64_t sequential_time = RDTSC_END() - start;
    
    printf("顺序写入: %lu 周期 (%.2f GB/s)\n", 
           sequential_time, 
           (double)data_size / sequential_time);
    
    // 模式2: 随机访问
    printf("\n2. 随机访问模式\n");
    srand(42);
    size_t *indices = malloc(data_size / 8 * sizeof(size_t));
    for (size_t i = 0; i < data_size / 8; i++) {
        indices[i] = (rand() % (data_size / 8)) * 8;
    }
    
    start = RDTSC_START();
    for (size_t i = 0; i < data_size / 8; i++) {
        data[indices[i]] = (char)(i & 0xFF);
    }
    uint64_t random_time = RDTSC_END() - start;
    
    printf("随机写入: %lu 周期 (%.2f GB/s)\n", 
           random_time, 
           (double)(data_size / 8) / random_time);
    
    // 模式3: 按缓存行对齐访问
    printf("\n3. 缓存行对齐访问\n");
    start = RDTSC_START();
    for (size_t i = 0; i < data_size; i += 64) {
        data[i] = (char)(i & 0xFF);
    }
    uint64_t aligned_time = RDTSC_END() - start;
    
    printf("对齐访问: %lu 周期 (%.2f GB/s)\n", 
           aligned_time, 
           (double)(data_size / 64) / aligned_time);
    
    // 清理
    free(indices);
    free(data);
}

// 缓存污染测试
void test_cache_pollution() {
    const size_t cache_size = get_l1_cache_size();
    char *polluter = malloc(cache_size * 2);
    char *victim = malloc(cache_size);
    
    printf("\n=== 缓存污染测试 ===\n");
    printf("L1缓存大小: %zu KB\n", cache_size / 1024);
    
    // 预热victim数据
    memset(victim, 0xAA, cache_size);
    
    // 测试victim的缓存命中
    uint64_t start = RDTSC_START();
    volatile char sum = 0;
    for (size_t i = 0; i < cache_size; i += 64) {
        sum += victim[i];
    }
    uint64_t clean_time = RDTSC_END() - start;
    
    // 污染缓存
    memset(polluter, 0xBB, cache_size * 2);
    
    // 再次测试victim（应该miss较多）
    start = RDTSC_START();
    for (size_t i = 0; i < cache_size; i += 64) {
        sum += victim[i];
    }
    uint64_t polluted_time = RDTSC_END() - start;
    
    printf("清洁缓存访问: %lu 周期\n", clean_time);
    printf("污染缓存访问: %lu 周期\n", polluted_time);
    printf("性能下降: %.2fx\n", (double)polluted_time / clean_time);
    
    free(polluter);
    free(victim);
}

int main() {
    printf("GCC O3性能回归诊断工具\n");
    printf("========================\n");
    
    // 打印系统信息
    printf("缓存配置:\n");
    printf("- 缓存行大小: %zu B\n", get_cache_line_size());
    printf("- L1缓存大小: %zu KB\n", get_l1_cache_size() / 1024);
    
    // 运行各种测试
    test_direct_mapped_conflicts();
    test_cache_locality();
    test_memory_patterns();
    test_cache_pollution();
    
    return 0;
}

3. 自动化诊断脚本

3.1 GCC O3 回归检测脚本

#!/bin/bash
# gcc_regression_detector.sh - 自动检测GCC优化回归

set -e

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
REPORT_FILE="${SCRIPT_DIR}/gcc_regression_report.md"

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

log_info() { echo -e "${GREEN}[INFO]${NC} $1"; }
log_warn() { echo -e "${YELLOW}[WARN]${NC} $1"; }
log_error() { echo -e "${RED}[ERROR]${NC} $1"; }

# 生成测试代码
generate_test_code() {
    local test_file="$1"
    
    cat > "$test_file" << 'EOF'
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 测试函数：矩阵乘法
void matrix_multiply(float *A, float *B, float *C, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            C[i*n + j] = 0.0f;
            for (int k = 0; k < n; k++) {
                C[i*n + j] += A[i*n + k] * B[k*n + j];
            }
        }
    }
}

// 测试函数：字符串处理
void process_strings(char **strings, int count) {
    for (int i = 0; i < count; i++) {
        int len = strlen(strings[i]);
        for (int j = 0; j < len; j++) {
            if (strings[i][j] >= 'a' && strings[i][j] <= 'z') {
                strings[i][j] -= 32;  // 转大写
            }
        }
    }
}

// 测试函数：数值计算
double complex_calculation(double x, int iterations) {
    double result = x;
    for (int i = 0; i < iterations; i++) {
        result = result * 1.0001 + result * 0.9999;
        result = result / 1.00005 + result * 0.99995;
    }
    return result;
}

int main(int argc, char *argv[]) {
    int matrix_size = 512;
    int string_count = 10000;
    int calc_iterations = 1000000;
    
    if (argc > 1) {
        matrix_size = atoi(argv[1]);
    }
    if (argc > 2) {
        string_count = atoi(argv[2]);
    }
    if (argc > 3) {
        calc_iterations = atoi(argv[3]);
    }
    
    // 矩阵乘法测试
    float *A = malloc(matrix_size * matrix_size * sizeof(float));
    float *B = malloc(matrix_size * matrix_size * sizeof(float));
    float *C = malloc(matrix_size * matrix_size * sizeof(float));
    
    for (int i = 0; i < matrix_size * matrix_size; i++) {
        A[i] = (float)(i % 1000) / 1000.0f;
        B[i] = (float)((i+1) % 1000) / 1000.0f;
        C[i] = 0.0f;
    }
    
    matrix_multiply(A, B, C, matrix_size);
    
    // 字符串处理测试
    char **strings = malloc(string_count * sizeof(char*));
    for (int i = 0; i < string_count; i++) {
        strings[i] = malloc(64);
        snprintf(strings[i], 64, "test_string_%d_lower_case", i);
    }
    
    process_strings(strings, string_count);
    
    // 数值计算测试
    double calc_result = 0.0;
    for (int i = 0; i < 100; i++) {
        calc_result += complex_calculation(1.0 + i * 0.01, calc_iterations);
    }
    
    // 输出结果（防止编译器优化掉计算）
    printf("Matrix result: %f\n", C[0]);
    printf("String result: %s\n", strings[0]);
    printf("Calc result: %f\n", calc_result);
    
    // 清理
    free(A); free(B); free(C);
    for (int i = 0; i < string_count; i++) {
        free(strings[i]);
    }
    free(strings);
    
    return 0;
}
EOF
}

# 运行性能测试
run_performance_test() {
    local opt_level="$1"
    local binary="$2"
    local test_output="$3"
    
    log_info "运行 ${opt_level} 优化测试..."
    
    # 编译
    if ! gcc "-$opt_level" -o "$binary" test_program.c -lm; then
        log_error "${opt_level} 编译失败"
        return 1
    fi
    
    # 获取二进制文件信息
    local binary_size=$(stat -f%z "$binary" 2>/dev/null || stat -c%s "$binary" 2>/dev/null || echo "unknown")
    log_info "${opt_level} 二进制大小: $binary_size 字节"
    
    # 运行多次测试取平均
    local total_time=0
    local iterations=5
    
    for ((i=1; i<=iterations; i++)); do
        local start_time=$(date +%s.%N 2>/dev/null || date +%s)
        ./"$binary" 512 5000 500000 > "$test_output" 2>&1
        local end_time=$(date +%s.%N 2>/dev/null || date +%s)
        
        # 计算执行时间（支持高精度时间）
        if command -v bc &> /dev/null; then
            local elapsed=$(echo "$end_time - $start_time" | bc -l 2>/dev/null || echo "0")
        else
            local elapsed=$((end_time - start_time))
        fi
        
        total_time=$(echo "$total_time + $elapsed" | bc -l 2>/dev/null || echo "$((total_time + elapsed))")
    done
    
    local avg_time=$(echo "scale=3; $total_time / $iterations" | bc -l 2>/dev/null || echo "N/A")
    log_info "${opt_level} 平均执行时间: $avg_time 秒"
    
    return 0
}

# 汇编代码分析
analyze_assembly() {
    local opt_level="$1"
    local asm_file="test_program.${opt_level}.s"
    
    log_info "生成 ${opt_level} 汇编代码..."
    
    if gcc "-$opt_level" -S -fverbose-asm -o "$asm_file" test_program.c; then
        local line_count=$(wc -l < "$asm_file")
        local file_size=$(stat -f%z "$asm_file" 2>/dev/null || stat -c%s "$asm_file" 2>/dev/null || echo "unknown")
        log_info "${opt_level} 汇编: $line_count 行, $file_size 字节"
        
        # 统计关键指令
        local call_count=$(grep -c '\bcall\b' "$asm_file" 2>/dev/null || echo "0")
        local branch_count=$(grep -c -E '\bj[a-z]+\b|\bje\b|\bjne\b' "$asm_file" 2>/dev/null || echo "0")
        local align_count=$(grep -c '\.p2align\|\.align' "$asm_file" 2>/dev/null || echo "0")
        
        log_info "${opt_level} 分析结果: $call_count 个调用, $branch_count 个分支, $align_count 个对齐指令"
    fi
}

# 主测试流程
main() {
    log_info "开始 GCC O3 性能回归检测"
    
    # 初始化
    mkdir -p test_results
    cd test_results
    
    # 生成测试代码
    log_info "生成测试代码..."
    generate_test_code "../test_program.c"
    
    # 测试不同优化级别
    local opt_levels=("O1" "O2" "O3")
    local test_results=()
    
    for level in "${opt_levels[@]}"; do
        local binary="test_${level}"
        local output="output_${level}.txt"
        
        if run_performance_test "$level" "$binary" "$output"; then
            test_results+=("$level")
            analyze_assembly "$level"
        fi
    done
    
    # 分析结果
    log_info "分析测试结果..."
    
    # 生成报告
    cat > "$REPORT_FILE" << EOF
# GCC 优化级别性能回归分析报告

生成时间: $(date)
测试程序: test_program.c

## 编译信息

EOF
    
    for level in "${test_results[@]}"; do
        local binary="test_${level}"
        if [ -f "$binary" ]; then
            local size=$(stat -f%z "$binary" 2>/dev/null || stat -c%s "$binary" 2>/dev/null || echo "unknown")
            echo "### ${level} 优化" >> "$REPORT_FILE"
            echo "- 二进制大小: $size 字节" >> "$REPORT_FILE"
            echo "- 汇编文件: test_program.${level}.s" >> "$REPORT_FILE"
            echo "" >> "$REPORT_FILE"
        fi
    done
    
    # 性能对比
    echo "## 性能对比分析" >> "$REPORT_FILE"
    echo "" >> "$REPORT_FILE"
    echo "| 优化级别 | 执行时间 | 二进制大小 | 相对性能 |" >> "$REPORT_FILE"
    echo "|---------|---------|-----------|---------|" >> "$REPORT_FILE"
    
    # 这里可以添加更详细的性能分析
    
    echo "" >> "$REPORT_FILE"
    echo "## 汇编代码特征" >> "$REPORT_FILE"
    echo "" >> "$REPORT_FILE"
    
    # 添加汇编分析结果
    
    log_info "报告生成完成: $REPORT_FILE"
    
    # 清理
    cd ..
    rm -rf test_results
}

# 检查依赖
check_dependencies() {
    local missing_deps=()
    
    if ! command -v gcc &> /dev/null; then
        missing_deps+=("gcc")
    fi
    
    if ! command -v bc &> /dev/null; then
        log_warn "bc 命令未找到，将使用简化的时间计算"
    fi
    
    if [ ${#missing_deps[@]} -gt 0 ]; then
        log_error "缺少依赖: ${missing_deps[*]}"
        exit 1
    fi
}

# 主函数
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
    check_dependencies
    main "$@"
fi

4. 使用说明

4.1 快速开始

# 1. 下载工具包
git clone <工具包地址>
cd gcc-o3-diagnostic-tools

# 2. 运行快速检测
./gcc_regression_detector.sh

# 3. 查看详细报告
cat gcc_regression_report.md

4.2 高级使用

# 编译分析
python3 asm_analyzer.py your_test.c O2 O3

# 内存层次结构分析
gcc -O3 -o memory_test memory_analyzer.c
./memory_test

# 完整基准测试
./optimize_benchmark.sh your_program.c

这套工具包提供了完整的 GCC O3 性能回归诊断解决方案，从自动化测试到详细分析，帮助工程师快速识别和解决优化相关的性能问题。

工具包版本: 1.0 兼容性: GCC 7.0+, Linux, macOS 许可证: MIT

查看归档