第9章：验证策略与健壮性设计

class tRCD_Checker:
    def __init__(self, tRCD_min):
        self.tRCD_min = tRCD_min
        self.act_timestamp = {}  # Bank -> timestamp

    def check_command(self, cmd, bank, timestamp):
        if cmd == "ACT":
            self.act_timestamp[bank] = timestamp

        elif cmd in ["READ", "WRITE"]:
            if bank in self.act_timestamp:
                elapsed = timestamp - self.act_timestamp[bank]
                if elapsed < self.tRCD_min:
                    return f"tRCD violation: {elapsed} < {self.tRCD_min}"
            else:
                return "READ/WRITE without ACT"

        elif cmd == "PRE":
            if bank in self.act_timestamp:
                del self.act_timestamp[bank]

        return "OK"

H = [1 0 1 0 1 0 1 0 1 0 0 0]
    [0 1 1 0 0 1 1 0 0 1 0 0]
    [0 0 0 1 1 1 1 0 0 0 1 0]
    [0 0 0 0 0 0 0 1 1 1 1 1]

触发条件：

- 单bit可纠正错误(CE)
- 错误率 < 100 CE/hour

恢复动作：

1. ECC硬件自动纠正
2. 更新错误计数器
3. 记录错误地址和时间

状态转换：
正常 → 纠错 → 正常 (< 10ns)

性能影响：~0%

触发条件：

- 错误率 > 100 CE/hour 或
- 检测到不可纠正错误(UE)
- 同一地址重复错误

恢复动作：

1. 触发中断通知软件
2. 软件执行memory scrubbing
3. 可能的页面迁移
4. 更新坏块列表

状态转换：
正常 → 中断 → 恢复 → 监控 (< 1ms)

性能影响：1-5%

触发条件：

- 连续UE错误
- 整个Rank/DIMM失效
- Level 2恢复失败

恢复动作：

1. 隔离故障内存区域
2. 系统内存容量降级
3. 可能的性能模式调整
4. 触发维护告警

状态转换：
正常 → 故障检测 → 隔离 → 降级运行 (< 100ms)

性能影响：20-50%

        ┌────────┐
        │ Normal │◀──────────┐
        └───┬────┘           │
            │ CE             │Recovery
            ▼                │Success
        ┌────────┐           │
        │Level 1 │───────────┘
        └───┬────┘
            │ Threshold
            ▼
        ┌────────┐
        │Level 2 │───────────┐
        └───┬────┘           │Recovery
            │ Fail           │Success
            ▼                ▼
        ┌────────┐      ┌────────┐
        │Level 3 │      │Monitor │
        └────────┘      └────────┘

class CoverageModel:
    def __init__(self):
        self.bins = {
            'cmd_type': ['ACT', 'PRE', 'READ', 'WRITE', 'REF'],
            'bank': range(16),
            'timing': ['min', 'typ', 'max'],
            'pattern': ['sequential', 'random', 'stride'],
            'crosses': []  # 交叉覆盖点
        }
        self.hit_count = {}

    def sample(self, transaction):
        # 更新覆盖率统计
        pass

class FeedbackEngine:
    def __init__(self):
        self.coverage_db = CoverageDatabase()
        self.constraint_solver = ConstraintSolver()

    def analyze_coverage(self):
        uncovered = self.coverage_db.get_uncovered_bins()
        return self.prioritize_bins(uncovered)

    def adjust_constraints(self, target_bins):
        # 动态调整约束以覆盖目标bin
        new_constraints = []
        for bin in target_bins:
            constraint = self.generate_constraint(bin)
            new_constraints.append(constraint)
        return new_constraints

Phase 1: 随机探索 (0-60%覆盖率)

- 使用默认约束随机生成
- 广泛探索状态空间
- 识别易覆盖和难覆盖的bin

Phase 2: 定向生成 (60-90%覆盖率)

- 分析未覆盖的bin
- 生成定向约束
- 优先覆盖高价值bin

Phase 3: 精确打靶 (90-95%覆盖率)

- 针对剩余corner case
- 手工编写特定测试
- 使用形式化方法辅助

Phase 4: 覆盖率收敛 (>95%)

- 分析不可达bin
- 调整覆盖率目标
- 生成覆盖率报告

def generate_test():
    while coverage < target:
        # 获取当前覆盖率
        current_cov = get_coverage()

        # 分析覆盖率洞
        holes = analyze_coverage_holes()

        # 生成针对性测试
        if current_cov < 0.6:
            test = random_test()
        elif current_cov < 0.9:
            test = directed_test(holes)
        else:
            test = corner_case_test(holes)

        # 运行测试并更新覆盖率
        run_test(test)
        update_coverage()

        # 自适应调整
        if not improving():
            adjust_strategy()

┌─────────────────────────────────────┐
│     Error Injection Framework       │
├─────────────────────────────────────┤
│  ┌─────────┐  ┌─────────────────┐  │
│  │ Config  │  │  Error Models   │  │
│  │ Manager │  │  Library        │  │
│  └─────────┘  └─────────────────┘  │
│  ┌─────────┐  ┌─────────────────┐  │
│  │Injection│  │   Trigger       │  │
│  │ Engine  │  │   Controller    │  │
│  └─────────┘  └─────────────────┘  │
│  ┌─────────┐  ┌─────────────────┐  │
│  │ Monitor │  │   Logger        │  │
│  │ & Trace │  │   & Reporter    │  │
│  └─────────┘  └─────────────────┘  │
└─────────────────────────────────────┘

class ErrorModel:
    def __init__(self):
        self.error_types = {
            'data': DataError(),
            'protocol': ProtocolError(),
            'timing': TimingError()
        }

class DataError:
    patterns = {
        'single_bit': lambda d: d ^ (1 << random(64)),
        'double_bit': lambda d: d ^ 0x41,  
        'burst': lambda d: d ^ 0xFF000000,
        'stuck_at': lambda d: 0xDEADBEEF
    }

class ProtocolError:
    violations = {
        'illegal_sequence': ['READ_without_ACT'],
        'bank_conflict': ['ACT_to_busy_bank'],
        'refresh_violation': ['miss_refresh']
    }

class TimingError:
    parameters = {
        'tRCD': {'min': 10, 'inject': 8},
        'tRP': {'min': 10, 'inject': 9},
        'tRAS': {'min': 28, 'inject': 25}
    }

class InjectionPoint:
    def __init__(self, name, location):
        self.name = name
        self.location = location
        self.enabled = False
        self.error_queue = []

    def inject(self, error):
        if self.enabled and self.should_inject():
            return self.apply_error(error)
        return None

injection_points = {
    'write_data': InjectionPoint('WR_DATA', 'dq_path'),
    'read_data': InjectionPoint('RD_DATA', 'dq_path'),
    'command': InjectionPoint('CMD', 'cmd_decoder'),
    'address': InjectionPoint('ADDR', 'addr_latch')
}

class TriggerController:
    def __init__(self):
        self.triggers = []

    def add_trigger(self, trigger):
        self.triggers.append(trigger)

class Trigger:
    def __init__(self, condition, action):
        self.condition = condition  # 触发条件
        self.action = action        # 注入动作
        self.count = 0

# 触发条件示例
triggers = [
    TimeTrigger(cycle=1000),      # 时间触发
    CountTrigger(n=100),           # 计数触发
    AddressTrigger(addr=0x1000),  # 地址触发
    RandomTrigger(prob=0.001),     # 随机触发
    PatternTrigger(pattern='RW')   # 模式触发
]

# error_injection_config.yaml
injection_scenarios:

  - name: "single_bit_error_test"
    error_type: "data.single_bit"
    injection_point: "read_data"
    trigger: 
      type: "random"
      probability: 0.0001
    duration: 10000

  - name: "timing_stress_test"
    error_type: "timing.tRCD"
    injection_point: "command"
    trigger:
      type: "pattern"
      pattern: "ACT->READ"
    duration: 5000

class ErrorMonitor:
    def __init__(self):
        self.injection_log = []
        self.detection_log = []
        self.recovery_log = []

    def log_injection(self, error, location, cycle):
        entry = {
            'cycle': cycle,
            'error': error,
            'location': location,
            'data_before': self.capture_state()
        }
        self.injection_log.append(entry)

    def log_detection(self, error, detector, cycle):
        # 记录错误检测
        pass

    def log_recovery(self, action, result, cycle):
        # 记录恢复动作
        pass

    def generate_report(self):
        return {
            'total_injected': len(self.injection_log),
            'total_detected': len(self.detection_log),
            'detection_rate': self.calc_detection_rate(),
            'recovery_success': self.calc_recovery_rate(),
            'mean_detection_latency': self.calc_latency()
        }

class ReplayManager:
    def __init__(self, seed=None):
        self.seed = seed or generate_seed()
        self.random_gen = RandomGenerator(self.seed)
        self.event_log = []

    def save_scenario(self, filename):
        scenario = {
            'seed': self.seed,
            'config': self.config,
            'events': self.event_log
        }
        save_to_file(scenario, filename)

    def replay_scenario(self, filename):
        scenario = load_from_file(filename)
        self.seed = scenario['seed']
        self.reset_random(self.seed)
        self.replay_events(scenario['events'])

# 创建测试场景
framework = ErrorInjectionFramework()
framework.load_config('error_config.yaml')

# 运行测试
framework.run_test(
    duration=100000,
    scenarios=['single_bit', 'timing_stress']
)

# 生成报告
report = framework.generate_report()
print(f"Detection Rate: {report['detection_rate']}%")
print(f"Recovery Success: {report['recovery_success']}%")

// Property 1: Bank状态一致性
// 一个Bank不能同时处于多个状态
property bank_state_consistency;
    @(posedge clk) disable iff (rst)
    (bank_state == IDLE) |-> 
    !(bank_state == ACTIVE || bank_state == PRECHARGING);
endproperty
assert_bank_state: assert property(bank_state_consistency);

// Property 2: 时序参数遵从性
// tRCD时序必须满足
property tRCD_compliance;
    @(posedge clk) disable iff (rst)
    (cmd == ACT) |-> 
    ##[tRCD_MIN:$] (cmd == READ || cmd == WRITE);
endproperty
assert_tRCD: assert property(tRCD_compliance);

// Property 3: 刷新周期保证
// 每个Bank必须在tREFI周期内刷新
property refresh_guarantee;
    @(posedge clk) disable iff (rst)
    (refresh_cmd) |-> 
    ##[1:tREFI_MAX] (refresh_cmd);
endproperty
assert_refresh: assert property(refresh_guarantee);

// Property 4: 请求最终完成
// 每个有效请求最终会被服务
property request_completion;
    @(posedge clk) disable iff (rst)
    (valid_request && !stall) |-> 
    strong(##[1:MAX_LATENCY] request_complete);
endproperty
assert_completion: assert property(request_completion);

// Property 5: 无死锁保证
// 系统不会永久停滞
property deadlock_freedom;
    @(posedge clk) disable iff (rst)
    (cmd_queue_not_empty) |-> 
    strong(##[1:DEADLOCK_TIMEOUT] cmd_issued);
endproperty
assert_no_deadlock: assert property(deadlock_freedom);

// Property 6: Bank访问公平性
// 所有Bank都有机会被访问
property bank_fairness;
    @(posedge clk) disable iff (rst)
    (bank_request[i]) |-> 
    strong(##[1:FAIRNESS_WINDOW] bank_grant[i]);
endproperty
generate
    for (genvar i = 0; i < NUM_BANKS; i++) begin
        assert_bank_fair: assert property(bank_fairness);
    end
endgenerate

// Property 7: 写后读一致性
// 写入的数据必须能正确读出
property read_after_write;
    logic [63:0] write_data;
    @(posedge clk) disable iff (rst)
    (write_cmd, write_data = wdata) |-> 
    ##[1:$] (read_cmd && same_addr) |-> 
    ##[CL] (rdata == write_data);
endproperty
assert_data_integrity: assert property(read_after_write);

// Property 8: 命令序列合法性
// 只允许合法的命令转换
property legal_cmd_sequence;
    @(posedge clk) disable iff (rst)
    case(prev_cmd)
        IDLE: (cmd inside {ACT, REF, SELF_REF});
        ACT: (cmd inside {READ, WRITE, PRE});
        READ: (cmd inside {READ, WRITE, PRE});
        WRITE: (cmd inside {READ, WRITE, PRE});
        PRE: (cmd inside {ACT, REF});
        default: 1'b1;
    endcase;
endproperty
assert_legal_sequence: assert property(legal_cmd_sequence);

// Property 9: tFAW约束
// 滑动窗口内最多4个激活
property tFAW_constraint;
    @(posedge clk) disable iff (rst)
    (act_count_in_window <= 4);
endproperty
assert_tFAW: assert property(tFAW_constraint);

// Property 10: 功耗状态转换
// 功耗状态转换必须遵循规定路径
property power_state_transition;
    @(posedge clk) disable iff (rst)
    (power_state == ACTIVE) |-> 
    (next_power_state inside {ACTIVE, PRECHARGE_PWR_DOWN});
endproperty
assert_power_transition: assert property(power_state_transition);