19.【SV】SystemVerilog Loops（循环）

芯片验证：循环（Loops）实战指南

朋友，循环是验证工程师的自动化引擎！让我用最直接的方式告诉你，为什么掌握各种循环就像拥有不同工具的瑞士军刀，能让你的验证代码从手动操作升级为自动化流水线。

一、循环核心概念：为什么需要循环？

一句话总结

“循环 = 让计算机重复做同样的事情，直到满足条件，解放你的双手”

// 没有循环：手动重复 → 工作量大，容易出错
$display("学生1成绩: 85");
$display("学生2成绩: 92");
$display("学生3成绩: 78");
// … 写100个学生，累死！

// 有循环：自动重复 → 一行代码搞定100个
for (int i = 0; i < 100; i++) begin
$display("学生%0d成绩: %0d", i+1, scores[i]);
end

// 记忆口诀：
// 手动重复 → 程序员累
// 自动循环 → 计算机累

二、六大循环类型：各有所长的工具

类型对比表

循环类型 | 使用场景 | 特点
———————|—————————————–|—————————–
forever | 永久运行的任务 | 永不停止，需要时间延迟
repeat | 固定次数重复 | 简单，只关心次数
while | 条件满足时重复 | 先检查条件，再执行
for | 有明确循环变量的重复 | 最常用，结构清晰
do while | 至少执行一次的循环 | 先执行，后检查
foreach | 遍历数组元素 | 专门为数组设计，最安全

三、forever循环：永不停止的引擎

核心特性：无限循环，必须有时延

module forever_demo;
bit clock = 0;

initial begin
$display("===== forever循环演示 =====");
$display("特点: 永不停止，必须有时延，否则仿真会挂起");

// ❌ 错误：没有时延的forever会导致仿真挂起
// forever begin
// $display("危险！没有时延！");
// end

// ✅ 正确：有时延的forever循环
forever begin
#10 clock = ~clock; // 每10ns翻转一次
$display("[%0t] 时钟翻转: %b", $time, clock);
end

// 注意：上面的forever循环永远不会结束
// 需要另一个initial块来结束仿真
end

// 控制仿真时间
initial begin
#100; // 运行100ns
$display("仿真结束");
$finish;
end
endmodule

// 验证实战：时钟生成器
module clock_generator;
bit clk;
real period = 10.0; // 10ns周期

initial begin
$display("启动时钟生成器，周期: %0.1fns", period);

forever begin
#(period/2.0) clk = 1'b0;
#(period/2.0) clk = 1'b1;
// 注意：这里没有$display，避免大量打印
end
end

// 监控时钟
initial begin
// 只打印前10个时钟边沿
repeat (20) begin
@(posedge clk);
$display("[%0t] 时钟上升沿", $time);
end
#50 $finish;
end
endmodule

实战应用：监控器和响应器

module monitor_example;
// 信号定义
bit reset_n = 1;
bit [7:0] data_bus;
bit valid = 0;

// 监控器：永远监控信号变化
initial begin
$display("启动信号监控器");

forever begin
// 等待任何信号变化
@(reset_n or data_bus or valid);

$display("[%0t] 信号变化:", $time);
$display(" reset_n = %b", reset_n);
$display(" data_bus = 0x%h", data_bus);
$display(" valid = %b", valid);
end
end

// 响应器：响应特定事件
initial begin
$display("启动事件响应器");

forever begin
// 等待有效数据
wait(valid == 1);
$display("[%0t] 收到有效数据: 0x%h", $time, data_bus);

// 处理数据…
#5 valid = 0; // 模拟处理时间
end
end

// 测试刺激
initial begin
// 初始状态
reset_n = 1;
data_bus = 8'h00;
valid = 0;

#10;

// 产生一些测试数据
for (int i = 0; i < 5; i++) begin
#20 data_bus = 8'h10 + i;
valid = 1;
#5 valid = 0;
end

#50 $display("测试完成");
$finish;
end
endmodule

四、repeat循环：固定次数的重复

核心特性：简单计数，不关心条件

module repeat_demo;
initial begin
$display("===== repeat循环演示 =====");
$display("特点: 固定次数重复，简单直接");

// 示例1：简单重复
$display("重复5次问候:");
repeat (5) begin
$display(" 你好！");
end

// 示例2：带计算的重复
int sum = 0;
repeat (10) begin
sum = sum + 1;
$display(" 第%0d次累加，总和: %0d", sum, sum);
end
$display("最终总和: %0d", sum);

// 示例3：嵌套repeat
$display("嵌套重复（乘法表）:");
repeat (3) begin // 外层：行
int row = 0;
repeat (3) begin // 内层：列
int col = 0;
$write(" (%0d,%0d)", row, col);
col++;
end
$display(""); // 换行
row++;
end
end
endmodule

// 验证实战：测试向量重复应用
module test_vector_repeat;
// 重复应用同一个测试向量多次
task apply_test_vector(bit [31:0] vector, int repeat_count);
$display("应用测试向量 0x%h，重复 %0d 次:", vector, repeat_count);

repeat (repeat_count) begin
// 这里应该是实际的硬件驱动
// drive_to_dut(vector);

// 等待响应
#10;

// 检查响应
// check_response();

$display(" 第%0d次应用完成", repeat_count);
end

$display("所有重复应用完成");
endtask

// 批量初始化内存
task initialize_memory(int base_addr, int size, bit [7:0] init_value);
$display("初始化内存: 地址 0x%h，大小 %0d，值 0x%h",
base_addr, size, init_value);

repeat (size) begin
// write_memory(base_addr, init_value);
base_addr = base_addr + 1; // 地址递增
$display(" 写入地址 0x%h: 0x%h", base_addr–1, init_value);
end

$display("内存初始化完成");
endtask

initial begin
// 测试1：重复应用向量
apply_test_vector(32'h12345678, 3);

// 测试2：初始化内存
initialize_memory(32'h40000000, 16, 8'hAA);
end
endmodule

高级应用：延迟和重试机制

module retry_mechanism;
// 带重试机制的任务
task send_packet_with_retry(bit [63:0] packet, int max_retries);
int retry_count = 0;
bit success = 0;

$display("发送数据包 0x%h，最大重试次数: %0d", packet, max_retries);

repeat (max_retries) begin
retry_count++;
$display(" 第%0d次尝试…", retry_count);

// 尝试发送（这里模拟随机成功）
if ($urandom_range(0, 1)) begin
success = 1;
$display(" 发送成功！");
break; // 成功则退出循环
end else begin
$display(" 发送失败，等待重试…");
#10; // 等待一段时间后重试
end
end

if (!success) begin
$error("发送失败，超过最大重试次数");
end
endtask

// 指数退避重试
task exponential_backoff(bit [63:0] packet, int max_retries);
int retry_count = 0;
int delay = 1; // 初始延迟1ns

$display("指数退避重试，数据包: 0x%h", packet);

repeat (max_retries) begin
retry_count++;
$display(" 尝试%0d，延迟%0dns", retry_count, delay);

#delay;

// 尝试发送
if ($urandom_range(0, 3) > 0) begin // 75%成功率
$display(" 发送成功！");
return;
end

// 失败：增加延迟（指数退避）
delay = delay * 2;
if (delay > 100) delay = 100; // 最大延迟100ns
end

$error("发送失败，重试%0d次后放弃", max_retries);
endtask

initial begin
// 测试重试机制
send_packet_with_retry(64'hDEADBEEF, 5);

#10;

// 测试指数退避
exponential_backoff(64'hCAFEBABE, 4);
end
endmodule

五、while循环：条件驱动的重复

核心特性：先检查，后执行

module while_demo;
initial begin
$display("===== while循环演示 =====");
$display("特点: 先检查条件，条件为真才执行");

// 示例1：简单计数器
$display("计数器从0到9:");
int count = 0;
while (count < 10) begin
$display(" 计数: %0d", count);
count++; // 必须改变条件变量，否则死循环！
end
$display("计数完成: %0d", count);

// 示例2：等待特定条件
$display("等待随机条件满足:");
bit condition = 0;
int attempts = 0;

while (!condition) begin
attempts++;
condition = $urandom_range(0, 1); // 随机条件
$display(" 尝试%0d: 条件=%b", attempts, condition);
#1; // 每次尝试间隔1ns
end
$display("条件满足！共尝试%0d次", attempts);

// 示例3：数据处理直到完成
$display("处理数据直到完成:");
int data_queue[$] = '{10, 20, 30, 40, 50};
int processed_count = 0;

while (data_queue.size() > 0) begin
int data = data_queue.pop_front();
$display(" 处理数据: %0d", data);
processed_count++;
#5; // 模拟处理时间
end
$display("数据处理完成，共处理%0d个", processed_count);
end
endmodule

// 验证实战：等待硬件响应
module wait_for_response;
// 模拟硬件信号
bit ready = 0;
bit done = 0;
bit [31:0] result;

// 等待就绪的任务
task wait_for_ready(int timeout);
int wait_time = 0;
$display("等待设备就绪（超时: %0dns）", timeout);

while (!ready && wait_time < timeout) begin
#1;
wait_time++;
if (wait_time % 10 == 0) begin
$display(" 已等待 %0dns，设备就绪: %b", wait_time, ready);
end
end

if (ready) begin
$display("设备就绪！等待时间: %0dns", wait_time);
end else begin
$error("等待超时！设备未就绪");
end
endtask

// 等待多个条件
task wait_for_multiple_conditions();
$display("等待多个条件满足:");

// 条件1：设备就绪
while (!ready) begin
$display(" 等待设备就绪…");
#5;
// 模拟设备变成就绪
if ($time > 20) ready = 1;
end
$display("条件1满足：设备就绪");

// 条件2：数据处理完成
while (!done) begin
$display(" 等待数据处理完成…");
#5;
// 模拟处理完成
if ($time > 40) begin
done = 1;
result = 32'h12345678;
end
end
$display("条件2满足：处理完成，结果: 0x%h", result);
endtask

// 超时保护机制
task wait_with_timeout(ref bit signal, int max_wait, string signal_name);
int wait_count = 0;

$display("等待信号 %s，超时限制: %0dns", signal_name, max_wait);

while (!signal && wait_count < max_wait) begin
#1;
wait_count++;
end

if (signal) begin
$display("信号 %s 在 %0dns 后变为真", signal_name, wait_count);
end else begin
$warning("等待信号 %s 超时！", signal_name);
end
endtask

initial begin
// 测试等待就绪
wait_for_ready(50);

#10;

// 测试等待多个条件
ready = 0;
done = 0;
wait_for_multiple_conditions();

#10;

// 测试超时保护
bit test_signal = 0;
wait_with_timeout(test_signal, 30, "test_signal");
end
endmodule

高级应用：复杂条件循环

module complex_while_conditions;
// 复杂条件判断
task monitor_system_health();
bit cpu_ok = 1;
bit memory_ok = 1;
bit io_ok = 1;
int error_count = 0;
int max_errors = 3;

$display("监控系统健康状态（最大允许错误: %0d）", max_errors);

// 只要系统基本健康且错误不超过阈值，就继续运行
while ((cpu_ok || memory_ok) && error_count < max_errors) begin
#10;

// 模拟随机错误
if ($urandom_range(0, 9) == 0) begin // 10%概率出错
error_count++;

// 随机选择哪个部件出错
case ($urandom_range(0, 2))
0: begin
cpu_ok = 0;
$display("[%0t] CPU错误！累计错误: %0d", $time, error_count);
end
1: begin
memory_ok = 0;
$display("[%0t] 内存错误！累计错误: %0d", $time, error_count);
end
2: begin
io_ok = 0;
$display("[%0t] IO错误！累计错误: %0d", $time, error_count);
end
endcase
end else begin
$display("[%0t] 系统正常: CPU=%b, 内存=%b, IO=%b",
$time, cpu_ok, memory_ok, io_ok);
end
end

if (error_count >= max_errors) begin
$error("达到最大错误数 %0d，系统停止", max_errors);
end else if (!cpu_ok && !memory_ok) begin
$error("关键部件失效，系统停止");
end else begin
$display("系统正常停止");
end
endtask

// 动态条件调整
task adaptive_processing(int data[]);
int processing_speed = 1; // 初始处理速度
int processed = 0;
int total = data.size();

$display("自适应处理 %0d 个数据", total);

while (processed < total) {
// 根据剩余数据量调整处理速度
int remaining = total – processed;

if (remaining > 100) {
processing_speed = 10; // 大量数据时快速处理
end else if (remaining > 10) {
processing_speed = 5; // 中等数据时中速处理
} else {
processing_speed = 1; // 少量数据时慢速处理（精确）
}

// 处理一批数据
int batch_size = (remaining < processing_speed) ?
remaining : processing_speed;

for (int i = 0; i < batch_size; i++) begin
// 处理数据
$display(" 处理数据[%0d] = %0d", processed, data[processed]);
processed++;
end

$display(" 进度: %0d/%0d (%.1f%%)，当前速度: %0d/批次",
processed, total,
100.0 * processed / total,
processing_speed);

#5; // 批次间延迟
}

$display("所有数据处理完成");
endtask

initial begin
// 测试系统健康监控
monitor_system_health();

#100;

// 测试自适应处理
int test_data[50];
foreach (test_data[i]) begin
test_data[i] = i * 10;
end
adaptive_processing(test_data);
end
endmodule

六、for循环：最常用的循环结构

核心特性：初始化、条件、更新三合一

module for_demo;
initial begin
$display("===== for循环演示 =====");
$display("特点: 初始化、条件检查、更新都在一行，结构清晰");

// 示例1：经典计数器
$display("经典计数器（0到9）:");
for (int i = 0; i < 10; i++) begin
$display(" i = %0d", i);
end

// 示例2：反向计数
$display("反向计数（9到0）:");
for (int j = 9; j >= 0; j—) begin
$display(" j = %0d", j);
end

// 示例3：步长不为1
$display("步长为2（0到10的偶数）:");
for (int k = 0; k <= 10; k = k + 2) begin
$display(" k = %0d", k);
end

// 示例4：多个循环变量
$display("多个循环变量:");
for (int a = 0, b = 10; a < 5 && b > 5; a++, b—) begin
$display(" a = %0d, b = %0d", a, b);
end

// 示例5：循环内部定义变量
$display("循环内部计算:");
for (int n = 1; n <= 5; n++) begin
int square = n * n;
int cube = n * n * n;
$display(" n=%0d, 平方=%0d, 立方=%0d", n, square, cube);
end
end
endmodule

// 验证实战：遍历和操作数组
module array_operations_with_for;
// 遍历和操作数组的各种方法

task print_array(int arr[]);
$display("数组内容（大小: %0d）:", arr.size());
for (int i = 0; i < arr.size(); i++) begin
$display(" arr[%0d] = %0d", i, arr[i]);
end
endtask

task initialize_array(ref int arr[], int size, int start_value);
arr = new[size];
for (int i = 0; i < size; i++) begin
arr[i] = start_value + i * 10;
end
$display("初始化数组完成");
endtask

task find_value(int arr[], int target);
$display("在数组中查找值 %0d:", target);

for (int i = 0; i < arr.size(); i++) begin
if (arr[i] == target) begin
$display(" 找到！索引: %0d", i);
return;
end
end

$display(" 未找到值 %0d", target);
endtask

task copy_array(int source[], ref int dest[]);
dest = new[source.size()];
for (int i = 0; i < source.size(); i++) begin
dest[i] = source[i];
end
$display("数组复制完成");
endtask

task reverse_array(ref int arr[]);
$display("反转数组:");
for (int i = 0, j = arr.size() – 1; i < j; i++, j—) begin
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
end
$display("数组反转完成");
endtask

initial begin
int my_array[];

// 初始化
initialize_array(my_array, 8, 100);
print_array(my_array);

// 查找
find_value(my_array, 130);
find_value(my_array, 999);

// 复制
int copied_array[];
copy_array(my_array, copied_array);
$display("复制后的数组:");
print_array(copied_array);

// 反转
reverse_array(my_array);
print_array(my_array);
end
endmodule

高级应用：嵌套循环和多维数组

module nested_loops;
// 二维数组操作
task print_matrix(int matrix[][], string name);
$display("矩阵 %s (%0d行 x %0d列):", name, matrix.size(),
matrix.size() > 0 ? matrix[0].size() : 0);

for (int i = 0; i < matrix.size(); i++) begin
$write(" 行%0d: ", i);
for (int j = 0; j < matrix[i].size(); j++) begin
$write("%4d", matrix[i][j]);
end
$display("");
end
endtask

task initialize_matrix(ref int matrix[][], int rows, int cols) ;
matrix = new[rows];
for (int i = 0; i < rows; i++) begin
matrix[i] = new[cols];
for (int j = 0; j < cols; j++) begin
matrix[i][j] = i * 10 + j;
end
end
$display("初始化矩阵 %0d x %0d", rows, cols);
endtask

task matrix_multiplication(int a[][], int b[][], ref int result[][]);
int rows_a = a.size();
int cols_a = a[0].size();
int rows_b = b.size();
int cols_b = b[0].size();

if (cols_a != rows_b) begin
$error("矩阵维度不匹配: %0d x %0d 不能乘以 %0d x %0d",
rows_a, cols_a, rows_b, cols_b);
return;
end

result = new[rows_a];
for (int i = 0; i < rows_a; i++) begin
result[i] = new[cols_b];
for (int j = 0; j < cols_b; j++) begin
result[i][j] = 0;
for (int k = 0; k < cols_a; k++) begin
result[i][j] += a[i][k] * b[k][j];
end
end
end

$display("矩阵乘法完成: (%0d x %0d) * (%0d x %0d) = (%0d x %0d)",
rows_a, cols_a, rows_b, cols_b, rows_a, cols_b);
endtask

// 图像处理：卷积操作（简化版）
task apply_convolution(ref int image[][], int kernel[][]) ;
int img_rows = image.size();
int img_cols = image[0].size();
int k_size = kernel.size();
int padding = k_size / 2;

// 创建带padding的图像
int padded_image[][];
padded_image = new[img_rows + 2*padding];
for (int i = 0; i < padded_image.size(); i++) begin
padded_image[i] = new[img_cols + 2*padding];
for (int j = 0; j < padded_image[i].size(); j++) begin
// 简单padding：复制边缘像素
int src_i = (i < padding) ? 0 :
((i >= img_rows + padding) ? img_rows–1 : i–padding);
int src_j = (j < padding) ? 0 :
((j >= img_cols + padding) ? img_cols–1 : j–padding);
padded_image[i][j] = image[src_i][src_j];
end
end

// 应用卷积
for (int i = 0; i < img_rows; i++) begin
for (int j = 0; j < img_cols; j++) begin
int sum = 0;
for (int ki = 0; ki < k_size; ki++) begin
for (int kj = 0; kj < k_size; kj++) begin
sum += padded_image[i+ki][j+kj] * kernel[ki][kj];
end
end
image[i][j] = sum;
end
end

$display("卷积应用完成，核大小: %0d x %0d", k_size, k_size);
endtask

initial begin
// 测试矩阵操作
int matrix_a[][];
int matrix_b[][];
int matrix_c[][];

initialize_matrix(matrix_a, 3, 4);
initialize_matrix(matrix_b, 4, 2);

print_matrix(matrix_a, "A");
print_matrix(matrix_b, "B");

matrix_multiplication(matrix_a, matrix_b, matrix_c);
print_matrix(matrix_c, "C (A × B)");

// 测试卷积
int small_image[][];
small_image = new[5];
for (int i = 0; i < 5; i++) begin
small_image[i] = new[5];
for (int j = 0; j < 5; j++) begin
small_image[i][j] = (i + j) % 10;
end
end

int blur_kernel[][];
blur_kernel = new[3];
for (int i = 0; i < 3; i++) begin
blur_kernel[i] = new[3];
for (int j = 0; j < 3; j++) begin
blur_kernel[i][j] = 1; // 均值模糊
end
end

$display("原始图像:");
print_matrix(small_image, "Image");

apply_convolution(small_image, blur_kernel);

$display("卷积后图像:");
print_matrix(small_image, "Blurred Image");
end
endmodule

七、do while循环：至少执行一次的循环

核心特性：先执行，后检查

module do_while_demo;
initial begin
$display("===== do while循环演示 =====");
$display("特点: 至少执行一次，执行后检查条件");

// 示例1：至少执行一次
$display("示例1：即使条件初始为假，也执行一次");
bit condition = 0;
int count = 0;

do begin
$display(" 执行第%0d次（条件=%b）", count+1, condition);
count++;
condition = (count < 3); // 执行3次
end while (condition);

$display("共执行 %0d 次", count);

// 示例2：用户输入验证（模拟）
$display("\\n示例2：模拟用户输入验证");
int user_input;
bit valid_input = 0;

do begin
// 模拟获取用户输入（这里用随机数）
user_input = $urandom_range(0, 10);
$display(" 用户输入: %0d", user_input);

// 验证输入
if (user_input >= 1 && user_input <= 5) begin
valid_input = 1;
$display(" 输入有效！");
end else begin
$display(" 输入无效，请重新输入（1-5）");
end
end while (!valid_input);

// 示例3：重试直到成功
$display("\\n示例3：重试机制");
int attempts = 0;
bit success = 0;

do begin
attempts++;
$display(" 尝试%0d: 执行操作…", attempts);

// 模拟操作（随机成功）
success = $urandom_range(0, 4) > 0; // 80%成功率

if (success) begin
$display(" 操作成功！");
end else begin
$display(" 操作失败，重试…");
#5; // 重试前等待
end
end while (!success && attempts < 5);

if (success) begin
$display("最终成功，尝试次数: %0d", attempts);
end else begin
$display("最终失败，超过最大尝试次数");
end
end
endmodule

// 验证实战：硬件初始化流程
module hardware_initialization;
// 模拟硬件初始化步骤
task initialize_hardware();
bit power_ok = 0;
bit clock_stable = 0;
bit reset_released = 0;
bit calibration_done = 0;
int step = 0;

$display("开始硬件初始化流程");

// 步骤1：上电（至少尝试一次）
do begin
step++;
$display("步骤%0d: 尝试上电…", step);

// 模拟上电（可能失败）
#10;
power_ok = $urandom_range(0, 1);

if (!power_ok) begin
$display(" 上电失败，重试…");
#5; // 等待后重试
end
end while (!power_ok && step < 3);

if (!power_ok) begin
$error("硬件上电失败");
return;
end
$display(" 上电成功");

// 步骤2：等待时钟稳定（至少检查一次）
do begin
step++;
$display("步骤%0d: 检查时钟稳定性…", step);

#20;
clock_stable = $urandom_range(0, 2) > 0; // 66%概率稳定

if (!clock_stable) begin
$display(" 时钟不稳定，继续等待…");
end
end while (!clock_stable && step < 10);

if (!clock_stable) begin
$error("时钟无法稳定");
return;
end
$display(" 时钟稳定");

// 步骤3：释放复位（至少执行一次）
do begin
step++;
$display("步骤%0d: 释放复位信号…", step);

#5;
reset_released = 1; // 假设总是成功

end while (!reset_released); // 实际上总是第一次就成功

$display(" 复位释放");

// 步骤4：校准（可能需要多次）
do begin
step++;
$display("步骤%0d: 执行校准…", step);

#30;
calibration_done = $urandom_range(0, 3) == 0; // 25%概率成功

if (!calibration_done) begin
$display(" 校准失败，重新校准…");
#10;
end
end while (!calibration_done && step < 15);

if (calibration_done) begin
$display("硬件初始化完成！总步骤: %0d", step);
end else begin
$error("校准失败，硬件初始化未完成");
end
endtask

// 模拟传感器读数直到稳定
task read_sensor_until_stable(ref real readings[], int max_samples);
real last_reading = 0.0;
real current_reading;
int sample_count = 0;
bit stable = 0;
real tolerance = 0.1;

$display("读取传感器直到稳定，最大样本数: %0d", max_samples);

do begin
sample_count++;

// 模拟传感器读数（带噪声）
current_reading = 25.0 + ($urandom_range(–100, 100) / 100.0);

$display(" 样本%0d: %.2f°C", sample_count, current_reading);

// 检查是否稳定（连续两次读数接近）
if (sample_count > 1) begin
if ($abs(current_reading – last_reading) < tolerance) begin
stable = 1;
$display(" 读数稳定在 %.2f°C", current_reading);
end
end

last_reading = current_reading;
readings = new[sample_count] (readings);
readings[sample_count–1] = current_reading;

#10; // 采样间隔

end while (!stable && sample_count < max_samples);

if (stable) begin
$display("传感器稳定，样本数: %0d", sample_count);
end else begin
$warning("传感器未在最大样本数内稳定");
end
endtask

initial begin
// 测试硬件初始化
initialize_hardware();

#100;

// 测试传感器读数
real sensor_data[];
read_sensor_until_stable(sensor_data, 20);
end
endmodule

八、foreach循环：数组遍历的专用工具

核心特性：自动遍历数组，无需管理索引

module foreach_demo;
initial begin
$display("===== foreach循环演示 =====");
$display("特点: 专门为数组设计，自动处理索引和边界");

// 示例1：一维数组
$display("遍历一维数组:");
int numbers[5] = '{10, 20, 30, 40, 50};

foreach (numbers[i]) begin
$display(" numbers[%0d] = %0d", i, numbers[i]);
end

// 示例2：多维数组
$display("\\n遍历二维数组:");
int matrix[3][4];

// 初始化矩阵
foreach (matrix[i,j]) begin
matrix[i][j] = i * 10 + j;
end

// 遍历矩阵
foreach (matrix[i,j]) begin
$display(" matrix[%0d][%0d] = %0d", i, j, matrix[i][j]);
end

// 示例3：动态数组
$display("\\n遍历动态数组:");
int dynamic_array[] = '{100, 200, 300, 400, 500};

foreach (dynamic_array[i]) begin
$display(" dynamic_array[%0d] = %0d", i, dynamic_array[i]);
end

// 示例4：队列
$display("\\n遍历队列:");
int queue[$] = '{5, 10, 15, 20, 25};

foreach (queue[i]) begin
$display(" queue[%0d] = %0d", i, queue[i]);
end

// 示例5：关联数组
$display("\\n遍历关联数组:");
int assoc_array[string];
assoc_array["苹果"] = 5;
assoc_array["香蕉"] = 3;
assoc_array["橙子"] = 8;

foreach (assoc_array[key]) begin
$display(" assoc_array[\\"%s\\"] = %0d", key, assoc_array[key]);
end
end
endmodule

// 验证实战：数组处理和统计
module array_processing_with_foreach;
// 使用foreach进行各种数组操作

task print_array_statistics(int arr[]);
if (arr.size() == 0) begin
$display("数组为空");
return;
end

int sum = 0;
int min_val = arr[0];
int max_val = arr[0];

// 使用foreach计算统计信息
foreach (arr[i]) begin
sum += arr[i];
if (arr[i] < min_val) min_val = arr[i];
if (arr[i] > max_val) max_val = arr[i];
end

real average = real'(sum) / arr.size();

$display("数组统计（大小: %0d）:", arr.size());
$display(" 总和: %0d", sum);
$display(" 平均值: %.2f", average);
$display(" 最小值: %0d", min_val);
$display(" 最大值: %0d", max_val);
endtask

task find_and_replace(ref int arr[], int find_val, int replace_val);
$display("查找并替换: %0d -> %0d", find_val, replace_val);
int replace_count = 0;

foreach (arr[i]) begin
if (arr[i] == find_val) begin
arr[i] = replace_val;
replace_count++;
$display(" 替换 arr[%0d]", i);
end
end

$display("共替换 %0d 个元素", replace_count);
endtask

task filter_array(int source[], ref int dest[], int threshold);
int temp[$];

$display("过滤数组（阈值: %0d）:", threshold);

// 使用foreach筛选元素
foreach (source[i]) begin
if (source[i] > threshold) begin
temp.push_back(source[i]);
$display(" 保留 source[%0d] = %0d", i, source[i]);
end
end

dest = temp;
$display("过滤完成，保留 %0d 个元素", dest.size());
endtask

task process_multidimensional_array(int matrix[][]) ;
$display("处理多维数组（%0d行 x %0d列）:",
matrix.size(), matrix.size() > 0 ? matrix[0].size() : 0);

// 计算每行的和
foreach (matrix[i]) begin
int row_sum = 0;

foreach (matrix[i][j]) begin
row_sum += matrix[i][j];
end

$display(" 行%0d的和: %0d", i, row_sum);
end

// 计算每列的平均值
if (matrix.size() > 0) begin
int cols = matrix[0].size();

for (int j = 0; j < cols; j++) begin
int col_sum = 0;

foreach (matrix[i]) begin
col_sum += matrix[i][j];
end

real col_avg = real'(col_sum) / matrix.size();
$display(" 列%0d的平均值: %.2f", j, col_avg);
end
end
endtask

initial begin
// 测试数据
int data[] = '{23, 45, 12, 67, 89, 34, 56, 78, 90, 15};
int filtered_data[];
int matrix[3][4];

// 初始化矩阵
foreach (matrix[i,j]) begin
matrix[i][j] = $urandom_range(1, 100);
end

// 测试统计
print_array_statistics(data);

// 测试查找替换
int data_copy[] = data;
find_and_replace(data_copy, 45, 99);

// 测试过滤
filter_array(data, filtered_data, 50);

// 测试多维数组处理
process_multidimensional_array(matrix);
end
endmodule

高级应用：复杂数据结构遍历

module complex_data_structures;
// 定义复杂数据结构
class Transaction;
int id;
string type;
int data;
real timestamp;

function new(int id, string type, int data);
this.id = id;
this.type = type;
this.data = data;
this.timestamp = $realtime;
endfunction

function void display();
$display(" 事务%0d [%s]: 数据=%0d, 时间=%.1f",
id, type, data, timestamp);
endfunction
endclass

// 类对象数组
Transaction tx_array[];

// 数组的数组
typedef int int_array[];
int_array array_of_arrays[];

// 关联数组的队列
int queue_by_category[string][$];

task initialize_test_data();
$display("初始化测试数据");

// 初始化事务数组
tx_array = new[5];
foreach (tx_array[i]) begin
string tx_type;
case (i % 3)
0: tx_type = "读";
1: tx_type = "写";
2: tx_type = "配置";
endcase
tx_array[i] = new(i, tx_type, i * 100);
end

// 初始化数组的数组
array_of_arrays = new[4];
foreach (array_of_arrays[i]) begin
array_of_arrays[i] = new[i+3]; // 每个子数组大小不同
foreach (array_of_arrays[i][j]) begin
array_of_arrays[i][j] = (i+1) * 10 + j;
end
end

// 初始化分类队列
queue_by_category["高优先级"] = '{100, 200, 300};
queue_by_category["中优先级"] = '{10, 20, 30, 40};
queue_by_category["低优先级"] = '{1, 2};
endtask

task process_transaction_array();
$display("处理事务数组:");

// 使用foreach遍历对象数组
foreach (tx_array[i]) begin
tx_array[i].display();

// 可以根据类型进行不同处理
case (tx_array[i].type)
"读": begin
$display(" 执行读操作");
end
"写": begin
$display(" 执行写操作");
end
"配置": begin
$display(" 执行配置操作");
end
endcase
end
endtask

task process_array_of_arrays();
$display("处理数组的数组:");

foreach (array_of_arrays[i]) begin
$display(" 子数组 %0d (大小: %0d):", i, array_of_arrays[i].size());

foreach (array_of_arrays[i][j]) begin
$write(" %4d", array_of_arrays[i][j]);
end
$display("");
end
endtask

task process_categorized_queues();
$display("处理分类队列:");

// 遍历每个分类
foreach (queue_by_category[category]) begin
$display(" 分类: %s (队列大小: %0d)",
category, queue_by_category[category].size());

// 遍历该分类的队列
foreach (queue_by_category[category][i]) begin
$display(" 项目%0d: %0d", i, queue_by_category[category][i]);
end

// 处理该分类的所有项目
while (queue_by_category[category].size() > 0) begin
int item = queue_by_category[category].pop_front();
$display(" 处理: %0d", item);
end
end
endtask

// 查找特定条件的元素
task find_transactions_by_type(string type);
$display("查找类型为 '%s' 的事务:", type);

foreach (tx_array[i]) begin
if (tx_array[i].type == type) begin
$display(" 找到: 事务%0d", tx_array[i].id);
end
end
endtask

// 使用foreach进行复杂过滤
task filter_and_process(ref Transaction transactions[], string filter_type) ;
Transaction filtered[$];

$display("过滤并处理类型为 '%s' 的事务:", filter_type);

// 过滤
foreach (transactions[i]) begin
if (transactions[i].type == filter_type) begin
filtered.push_back(transactions[i]);
end
end

// 处理过滤后的事务
foreach (filtered[i]) begin
$display(" 处理过滤后的事务%0d", filtered[i].id);
end

$display("共找到 %0d 个匹配的事务", filtered.size());
endtask

initial begin
initialize_test_data();

process_transaction_array();

process_array_of_arrays();

process_categorized_queues();

find_transactions_by_type("写");

filter_and_process(tx_array, "读");
end
endmodule

九、循环性能优化与最佳实践

最佳实践1：选择合适的循环类型

module loop_selection_guide;
initial begin
$display("===== 循环选择指南 =====");

// 场景1：已知固定次数 → 用for或repeat
$display("场景1：已知固定次数");
$display(" 推荐: for 或 repeat");
$display(" 示例:");

// for循环（更灵活）
for (int i = 0; i < 10; i++) begin
// 处理
end

// repeat循环（更简单）
repeat (10) begin
// 处理
end

// 场景2：条件驱动，可能一次都不执行 → 用while
$display("\\n场景2：条件驱动，可能零次");
$display(" 推荐: while");
$display(" 示例:");

bit condition = 0;
while (condition) begin
// 可能永远不会执行
end

// 场景3：至少执行一次 → 用do while
$display("\\n场景3：至少执行一次");
$display(" 推荐: do while");
$display(" 示例:");

do begin
// 至少执行一次
condition = 0; // 第一次执行后条件变假
end while (condition);

// 场景4：遍历数组 → 用foreach
$display("\\n场景4：遍历数组");
$display(" 推荐: foreach（最安全）");
$display(" 示例:");

int array[5];
foreach (array[i]) begin
// 自动处理边界
end

// 场景5：无限循环 → 用forever（小心！）
$display("\\n场景5：无限循环");
$display(" 推荐: forever（必须有时间延迟）");
$display(" 示例:");

// forever begin
// #10; // 必须有延迟！
// // 处理
// end

$display("\\n记住：选择最符合场景的循环类型！");
end
endmodule

最佳实践2：避免常见陷阱

module loop_pitfalls;
initial begin
$display("===== 循环常见陷阱 =====");

// 陷阱1：死循环（没有退出条件或条件永远为真）
$display("陷阱1：死循环");
$display(" ❌ 错误示例:");
// int x = 0;
// while (x < 5) begin
// $display("x = %0d", x);
// // 忘记 x++，导致死循环！
// end

$display(" ✅ 正确示例:");
int x = 0;
while (x < 5) begin
$display(" x = %0d", x);
x++; // 确保改变条件变量
end

// 陷阱2：数组越界
$display("\\n陷阱2：数组越界");
$display(" ❌ 错误示例:");
int arr[5];
// for (int i = 0; i <= 5; i++) begin // i=5 时越界！
// arr[i] = i;
// end

$display(" ✅ 正确示例（使用for）:");
for (int i = 0; i < 5; i++) begin // i<5，不是i<=5
arr[i] = i;
end

$display(" ✅ 更好示例（使用foreach）:");
foreach (arr[i]) begin // 自动处理边界
arr[i] = i;
end

// 陷阱3：forever循环没有时间延迟
$display("\\n陷阱3：forever循环没有时间延迟");
$display(" ❌ 错误示例:");
// forever begin
// $display("无限打印，仿真挂起！");
// end

$display(" ✅ 正确示例:");
// forever begin
// #10; // 必须有时间延迟
// $display("安全打印");
// end

// 陷阱4：循环内创建大量对象不释放
$display("\\n陷阱4：内存泄漏");
$display(" ❌ 错误示例:");
// for (int i = 0; i < 1000000; i++) begin
// my_class obj = new(); // 每次循环创建新对象
// // 使用obj…
// // 忘记删除或超出作用域后自动回收可能不及时
// end

$display(" ✅ 正确示例:");
// my_class obj = new(); // 在循环外创建
// for (int i = 0; i < 1000000; i++) begin
// obj.reset(); // 重用对象
// // 使用obj…
// end

// 陷阱5：嵌套循环性能问题
$display("\\n陷阱5：嵌套循环性能");
$display(" ❌ 错误示例（O(n³)复杂度）:");
// for (int i = 0; i < n; i++) begin
// for (int j = 0; j < n; j++) begin
// for (int k = 0; k < n; k++) begin
// // 复杂操作
// end
// end
// end

$display(" ✅ 优化建议:");
$display(" 1. 减少不必要的嵌套");
$display(" 2. 将不变的计算提到外层循环");
$display(" 3. 使用更高效的算法");

$display("\\n记住：编写循环时要考虑性能和安全性！");
end
endmodule

最佳实践3：循环性能优化技巧

module loop_performance;
// 性能优化技巧

task demonstrate_optimizations();
int large_array[10000];
int sum = 0;

// 初始化大数组
foreach (large_array[i]) begin
large_array[i] = $urandom_range(1, 1000);
end

$display("循环性能优化演示（数组大小: %0d）", large_array.size());

// 技巧1：减少循环内部的计算
$display("\\n技巧1：减少循环内部的计算");

real start_time, end_time;

// ❌ 不好：在循环内重复计算
start_time = $realtime;
for (int i = 0; i < large_array.size(); i++) begin
sum += large_array[i] * large_array[i]; // 每次循环计算平方
end
end_time = $realtime;
$display(" 方法1（直接计算）: %.3f ns", end_time – start_time);

// ✅ 好：使用局部变量
start_time = $realtime;
for (int i = 0; i < large_array.size(); i++) begin
int value = large_array[i]; // 一次数组访问
sum += value * value; // 使用局部变量
end
end_time = $realtime;
$display(" 方法2（局部变量）: %.3f ns", end_time – start_time);

// 技巧2：循环展开（部分展开）
$display("\\n技巧2：循环展开");

sum = 0;
start_time = $realtime;
for (int i = 0; i < large_array.size(); i += 4) begin
// 一次处理4个元素
if (i < large_array.size()) sum += large_array[i];
if (i+1 < large_array.size()) sum += large_array[i+1];
if (i+2 < large_array.size()) sum += large_array[i+2];
if (i+3 < large_array.size()) sum += large_array[i+3];
end
end_time = $realtime;
$display(" 循环展开（4个一组）: %.3f ns", end_time – start_time);

// 技巧3：使用foreach代替for（更安全，有时更快）
$display("\\n技巧3：使用foreach");

sum = 0;
start_time = $realtime;
foreach (large_array[i]) begin
sum += large_array[i];
end
end_time = $realtime;
$display(" foreach循环: %.3f ns", end_time – start_time);

// 技巧4：避免在紧密循环中调用函数
$display("\\n技巧4：避免函数调用开销");

// 假设有一个简单的计算函数
function int compute(int x);
return x * x;
endfunction

sum = 0;
start_time = $realtime;
for (int i = 0; i < 1000; i++) begin // 小循环演示
sum += compute(large_array[i]); // 每次循环调用函数
end
end_time = $realtime;
$display(" 循环内调用函数: %.3f ns", end_time – start_time);

// 内联计算，避免函数调用
sum = 0;
start_time = $realtime;
for (int i = 0; i < 1000; i++) begin
sum += large_array[i] * large_array[i]; // 直接计算
end
end_time = $realtime;
$display(" 内联计算: %.3f ns", end_time – start_time);

$display("\\n性能优化总结:");
$display(" 1. 减少循环内部的计算和函数调用");
$display(" 2. 使用局部变量缓存重复访问的值");
$display(" 3. 考虑循环展开（但不要过度）");
$display(" 4. 使用foreach遍历数组（安全和简洁）");
$display(" 5. 对于大数组，注意内存访问模式");
endtask

// 特定场景优化：查找操作
task optimize_search_operations();
int data[1000];
int target = 42;
bit found = 0;

// 初始化数据
foreach (data[i]) begin
data[i] = $urandom_range(1, 1000);
}
// 确保目标存在
data[500] = target;

$display("\\n查找操作优化:");

// 方法1：普通查找
real start_time = $realtime;
for (int i = 0; i < data.size(); i++) begin
if (data[i] == target) begin
found = 1;
$display(" 普通查找: 在索引 %0d 找到", i);
break; // 找到后立即退出
end
end
real end_time = $realtime;
$display(" 时间: %.3f ns", end_time – start_time);

// 方法2：使用while可能更快
found = 0;
start_time = $realtime;
int index = 0;
while (!found && index < data.size()) begin
if (data[index] == target) begin
found = 1;
$display(" while查找: 在索引 %0d 找到", index);
end
index++;
end
end_time = $realtime;
$display(" 时间: %.3f ns", end_time – start_time);

// 方法3：如果数据有序，可以使用二分查找
$display("\\n对于有序数组，使用二分查找:");
// 先排序（模拟有序数组）
data.sort();

// 二分查找实现
start_time = $realtime;
int left = 0;
int right = data.size() – 1;
found = 0;

while (left <= right) begin
int mid = (left + right) / 2;

if (data[mid] == target) begin
found = 1;
$display(" 二分查找: 在索引 %0d 找到", mid);
break;
end else if (data[mid] < target) begin
left = mid + 1;
end else begin
right = mid – 1;
end
end
end_time = $realtime;
$display(" 时间: %.3f ns", end_time – start_time);
endtask

initial begin
demonstrate_optimizations();
optimize_search_operations();
end
endmodule

十、常见面试问题与答案

问题1：forever、while(1)和repeat($)有什么区别？

答：
这三个都是无限循环，但有重要区别：

推荐使用forever，因为：

• 语义最明确
• SystemVerilog专为此设计
• 代码可读性更好

示例对比：

// 推荐
forever begin
#10 clock = ~clock;
end

// 也可以，但不推荐（更像是C风格）
while (1) begin
#10 clock = ~clock;
end

// 不推荐，容易误解
// repeat($) begin // $在这里不合适
// #10 clock = ~clock;
// end

问题2：for循环和foreach循环在遍历数组时有什么区别？

答：
主要区别：

选择建议：

• 大多数情况：使用foreach（更安全，代码更简洁）
• 需要复杂索引控制时：使用for（更灵活）
• 性能关键路径：根据实际情况测试选择

问题3：do while和while循环有什么区别？什么时候用哪个？

答：
关键区别：执行顺序不同

使用场景：

使用do when当：

使用while当：

示例对比：

// 场景：等待设备就绪
// 使用while（设备可能已经就绪）
while (!device_ready) begin
#10; // 等待
end

// 场景：获取用户输入直到有效
// 使用do while（至少需要获取一次输入）
do begin
input = get_user_input();
valid = validate(input);
end while (!valid);

记忆口诀：

• while：先问后做（可能不做）
• do while：先做后问（至少做一次）

十一、总结：循环是验证自动化的基石

循环的核心价值总结

// 1. 自动化：让计算机做重复工作
for (int i = 0; i < 1000; i++) begin
apply_test_vector(test_vectors[i]);
end

// 2. 条件控制：智能执行
while (!device_ready) begin
wait_for_response();
end

// 3. 遍历数据：轻松处理集合
foreach (data_array[i]) begin
process_data(data_array[i]);
end

// 4. 永久运行：持续监控
forever begin
#10 monitor_signals();
end

给验证工程师的终极建议

记住：好的验证工程师不是写最多代码的人，而是写最有效代码的人。合理使用循环，让你的验证代码更简洁、更高效、更强大。