目次

目次
1. はじめに
2. 本質要素抽象化の設計方針
3. コード
ライセンス

1. はじめに

このドキュメントはAIに読み込ませてコードを自動生成することを目標としています。

第7回でテストベンチの自動生成を試みましたが、期待した結果が得られませんでした。このドキュメントとコードはCursorのProモードを使用して作成しています。

Proモードの特徴として、月初めにはコード全体を読み込んで包括的な回答を提供します。しかし、この状態であいまいな指示でAIにデバッグを依頼すると、トークンの消費が激しく、短期間で使い切ってしまいます。トークンを使い切った後は、コードの一部しか参照できない制限されたモードに移行します。

第7回と第8回では、この制限された状態でCursorに適切な指示を出し、効果的な設計を実現する試みを行っています。本質要素抽象化の設計手法により、限られた情報でも質の高いコード生成が可能になることを目指しています。

2. 本質要素抽象化の設計方針

まず、テストベンチの基本要素を考えてみましょう。

テストベンチの設計において、本質的な要素を抽象化することで、再利用性と保守性を大幅に向上させることができます。以下に、6つの基本要素を定義します：

テストベンチの基本要素

1. パラメータ設定系（最優先）

テスト動作パラメータ: テストベンチの動作を定義する設定値
モジュールTOP指示パラメータ: テスト対象モジュールへの指示パラメータ
テスト条件パラメータ: テストの実行条件や制約を定義するパラメータ

2. ハードウェア制御系

クロック制御: システムクロックの生成と制御
リセット制御: リセット信号の生成と制御

3. テストデータ生成・制御系

スティミュラス生成: テストパターンやテストベクタの生成

4. データ検証系

期待値比較: 出力データと期待値の照合
タイミング検証: 信号のタイミング要件の確認

5. プロトコル検証系

AXI4仕様準拠性チェック: プロトコル要件の検証
ハンドシェイク検証: Ready/Valid信号の動作確認
バースト転送検証: バーストモードの動作確認

6. 監視・ログ系

テストシーケンス制御: テストデータ制御とデータ検証のスタートストップ制御・監視
信号監視: 重要な信号の状態監視
エラー検出: 異常動作の検出と報告
タイムアウト監視: テストの実行時間制限とタイムアウト検出
ログ出力: テスト実行結果の記録

7. 重み付き乱数発生系

重み付き乱数生成: 特定の値の出現頻度を制御する乱数生成

これらの要素を独立したモジュールとして実装し、パラメータによる設定変更が可能にすることで、様々なテストシナリオに対応できる柔軟なテストベンチフレームワークを構築できます。

2.1 パラメータ設定系

テストベンチの動作を定義するパラメータを体系的に設定することで、様々なテストシナリオに対応できる柔軟なシステムを構築します。

基本パラメータ設定

// テストベンチの基本パラメータ設定
module axi4_testbench_params;
    // メモリサイズとデータ幅の設定
    parameter MEMORY_SIZE_BYTES = 33554432;     // 32MB
    parameter AXI_DATA_WIDTH = 32;              // 32bit
    parameter AXI_ID_WIDTH = 8;                 // 8bit ID
    
    // テスト実行回数の設定
    parameter TOTAL_TEST_COUNT = 1000;          // 総テスト回数
    parameter PHASE_TEST_COUNT = 2;             // 1Phase当たりのテスト回数
    
    // 1テストカウント毎のアドレス領域サイズ設定
    parameter TEST_COUNT_ADDR_SIZE_BYTES = 4096;     // 1テストカウント毎のアドレス領域サイズ（4KB）
    
    // 自動計算されるパラメータ
    parameter AXI_ADDR_WIDTH = $clog2(MEMORY_SIZE_BYTES);           // アドレス幅（自動計算）
    parameter AXI_STRB_WIDTH = AXI_DATA_WIDTH / 8;                  // ストローブ幅（自動計算）
    
    // バブル発生確率の設定（重み付き乱数パラメータ）
    typedef struct {
        int cyc_cnt_start;  // 開始サイクル数
        int cyc_cnt_end;    // 終了サイクル数
        int weight;         // 重み（出現確率）
    } bubble_param_t;
    
    // Writeアドレスバブルの確率設定
    bubble_param_t write_addr_bubble_weights[int];
    
    // Readアドレスバブルの確率設定
    bubble_param_t read_addr_bubble_weights[int];
    
    // Writeデータバブルの確率設定
    bubble_param_t write_data_bubble_weights[int];
    
    // b_Readyネゲートの確率設定
    bubble_param_t b_ready_negate_weights[int];
    
    // ReadデータReadyネゲートの確率設定
    bubble_param_t r_ready_negate_weights[int];
    
    // バースト設定を統合した構造体（範囲ベース）
    typedef struct {
        int length_min;       // バースト長の最小値
        int length_max;       // バースト長の最大値
        string burst_type;    // バーストタイプ（"FIXED", "INCR", "WRAP"）
        int weight;           // 重み（出現確率）
    } burst_config_t;
    
    // 統合されたバースト設定配列
    burst_config_t burst_config_weights[int];
    
    // パラメータの初期化
    initial begin
        // Writeアドレスバブルの確率設定
        write_addr_bubble_weights = '{
            0: '{cyc_cnt_start: 0, cyc_cnt_end: 0, weight: 60},    // バブルなし（60%）
            1: '{cyc_cnt_start: 1, cyc_cnt_end: 1, weight: 25},    // 1サイクルバブル（25%）
            2: '{cyc_cnt_start: 2, cyc_cnt_end: 2, weight: 10},    // 2サイクルバブル（10%）
            3: '{cyc_cnt_start: 3, cyc_cnt_end: 3, weight: 5}      // 3サイクルバブル（5%）
        };
        
        // Readアドレスバブルの確率設定
        read_addr_bubble_weights = '{
            0: '{cyc_cnt_start: 0, cyc_cnt_end: 0, weight: 70},    // バブルなし（70%）
            1: '{cyc_cnt_start: 1, cyc_cnt_end: 1, weight: 20},    // 1サイクルバブル（20%）
            2: '{cyc_cnt_start: 2, cyc_cnt_end: 2, weight: 8},     // 2サイクルバブル（8%）
            3: '{cyc_cnt_start: 3, cyc_cnt_end: 3, weight: 2}      // 3サイクルバブル（2%）
        };
        
        // Writeデータバブルの確率設定
        write_data_bubble_weights = '{
            0: '{cyc_cnt_start: 0, cyc_cnt_end: 0, weight: 65},    // バブルなし（65%）
            1: '{cyc_cnt_start: 1, cyc_cnt_end: 1, weight: 22},    // 1サイクルバブル（22%）
            2: '{cyc_cnt_start: 2, cyc_cnt_end: 2, weight: 10},    // 2サイクルバブル（10%）
            3: '{cyc_cnt_start: 3, cyc_cnt_end: 3, weight: 3}      // 3サイクルバブル（3%）
        };
        
        // b_Readyネゲートの確率設定
        b_ready_negate_weights = '{
            0: '{cyc_cnt_start: 0, cyc_cnt_end: 0, weight: 50},    // ネゲートなし（50%）
            1: '{cyc_cnt_start: 1, cyc_cnt_end: 1, weight: 30},    // 1サイクルネゲート（30%）
            2: '{cyc_cnt_start: 2, cyc_cnt_end: 2, weight: 15},    // 2サイクルネゲート（15%）
            3: '{cyc_cnt_start: 3, cyc_cnt_end: 3, weight: 4},     // 3サイクルネゲート（4%）
            4: '{cyc_cnt_start: 4, cyc_cnt_end: 8, weight: 1}      // 4-8サイクルネゲート（1%）
        };
        
        // ReadデータReadyネゲートの確率設定
        r_ready_negate_weights = '{
            0: '{cyc_cnt_start: 0, cyc_cnt_end: 0, weight: 55},    // ネゲートなし（55%）
            1: '{cyc_cnt_start: 1, cyc_cnt_end: 1, weight: 28},    // 1サイクルネゲート（28%）
            2: '{cyc_cnt_start: 2, cyc_cnt_end: 2, weight: 12},    // 2サイクルネゲート（12%）
            3: '{cyc_cnt_start: 3, cyc_cnt_end: 3, weight: 4},     // 3サイクルネゲート（4%）
            4: '{cyc_cnt_start: 4, cyc_cnt_end: 8, weight: 1}      // 4-8サイクルネゲート（1%）
        };
        
        // 統合されたバースト設定の初期化
        burst_config_weights = '{
            0: '{length_min: 1, length_max: 1, burst_type: "INCR", weight: 28},     // INCR, LENGTH=1（28%）
            1: '{length_min: 1, length_max: 1, burst_type: "WRAP", weight: 8},      // WRAP, LENGTH=1（8%）
            2: '{length_min: 1, length_max: 1, burst_type: "FIXED", weight: 4},     // FIXED, LENGTH=1（4%）
            3: '{length_min: 2, length_max: 4, burst_type: "INCR", weight: 15},     // INCR, LENGTH=2-4（15%）
            4: '{length_min: 2, length_max: 4, burst_type: "WRAP", weight: 4},      // WRAP, LENGTH=2-4（4%）
            5: '{length_min: 2, length_max: 4, burst_type: "FIXED", weight: 2},     // FIXED, LENGTH=2-4（2%）
            6: '{length_min: 5, length_max: 8, burst_type: "INCR", weight: 10},     // INCR, LENGTH=5-8（10%）
            7: '{length_min: 5, length_max: 8, burst_type: "WRAP", weight: 3},      // WRAP, LENGTH=5-8（3%）
            8: '{length_min: 5, length_max: 8, burst_type: "FIXED", weight: 1},     // FIXED, LENGTH=5-8（1%）
            9: '{length_min: 9, length_max: 16, burst_type: "INCR", weight: 8},     // INCR, LENGTH=9-16（8%）
            10: '{length_min: 9, length_max: 16, burst_type: "WRAP", weight: 2},    // WRAP, LENGTH=9-16（2%）
            11: '{length_min: 9, length_max: 16, burst_type: "FIXED", weight: 1},   // FIXED, LENGTH=9-16（1%）
            12: '{length_min: 17, length_max: 32, burst_type: "INCR", weight: 6},   // INCR, LENGTH=17-32（6%）
            13: '{length_min: 33, length_max: 64, burst_type: "INCR", weight: 4},   // INCR, LENGTH=63（4%）
            14: '{length_min: 65, length_max: 128, burst_type: "INCR", weight: 2}   // INCR, LENGTH=65-128（2%）
        };
    end
    
    // WRAP転送時のアドレス生成関数
    function automatic logic [AXI_ADDR_WIDTH-1:0][] generate_wrap_addresses(
        input logic [AXI_ADDR_WIDTH-1:0] start_address,
        input int length
    );
        logic [AXI_ADDR_WIDTH-1:0] addresses[];
        int burst_length = length + 1;
        int wrap_boundary;
        int boundary_mask;
        
        // AXI4規格チェック: LENGTHの制約
        if (length < 1 || length > 255) begin
            $error("AXI4 WRAP: Invalid LENGTH value %0d. LENGTH must be 1-255", length);
            $finish;
        end
        
        // AXI4規格チェック: バースト長は2のN乗である必要がある
        if ((burst_length & (burst_length - 1)) != 0) begin
            $error("AXI4 WRAP: Invalid burst length %0d. Burst length must be power of 2", burst_length);
            $finish;
        end
        
        // AXI4規格チェック: アドレスは境界の倍数である必要がある
        wrap_boundary = burst_length;
        if ((start_address % wrap_boundary) != 0) begin
            $error("AXI4 WRAP: Address 0x%h is not aligned to %0d-byte boundary", start_address, wrap_boundary);
            $finish;
        end
        
        // 配列サイズを設定
        addresses = new[burst_length];
        
        // 境界マスクを計算（境界サイズ-1）
        boundary_mask = wrap_boundary - 1;
        
        // 各転送のアドレスを生成
        for (int i = 0; i < burst_length; i++) begin
            // 基本アドレス（境界内のオフセット）
            addresses[i] = start_address + i;
            
            // 境界を超えた場合のラップアラウンド処理
            if ((addresses[i] & boundary_mask) >= wrap_boundary) begin
                addresses[i] = (start_address & ~boundary_mask) | (i & boundary_mask);
            end
        end
        
        return addresses;
    endfunction
    
    // シングルアクセス時のストローブ組み合わせ生成関数（2のN乗制限版）
    typedef struct {
        logic [AXI_STRB_WIDTH-1:0] strobe;  // ストローブパターン
        int byte_count;                      // バイト数
    } strobe_combination_t;
    
    function automatic strobe_combination_t[] generate_strobe_combinations(int strb_width);
        strobe_combination_t combinations[];
        int combination_count = 0;
        
        // 2のN乗のバイト数とオフセットのみを生成
        for (int byte_count = 1; byte_count <= strb_width; byte_count = byte_count << 1) begin
            if (byte_count > strb_width) break;
            
            for (int byte_offset = 0; byte_offset < strb_width; byte_offset = byte_offset + byte_count) begin
                if (byte_offset + byte_count <= strb_width) begin
                    combination_count++;
                end
            end
        end
        
        // 配列サイズを設定
        combinations = new[combination_count];
        
        // 各組み合わせを生成
        int idx = 0;
        for (int byte_count = 1; byte_count <= strb_width; byte_count = byte_count << 1) begin
            if (byte_count > strb_width) break;
            
            for (int byte_offset = 0; byte_offset < strb_width; byte_offset = byte_offset + byte_count) begin
                if (byte_offset + byte_count <= strb_width) begin
                    logic [strb_width-1:0] strobe = 0;
                    
                    // ストローブパターンを生成
                    for (int i = 0; i < strb_width; i++) begin
                        if (i >= byte_offset && i < byte_offset + byte_count) begin
                            strobe[i] = 1'b1;
                        end
                    end
                    
                    // 配列に格納
                    combinations[idx].strobe = strobe;
                    combinations[idx].byte_count = byte_count;
                    idx++;
                end
            end
        end
        
        return combinations;
    endfunction
    
    // パラメータ表示関数
    function automatic void display_parameters();
        $display("=== AXI4 Testbench Parameters ===");
        $display("Memory Size: %0d bytes", MEMORY_SIZE_BYTES);
        $display("Data Width: %0d bits", AXI_DATA_WIDTH);
        $display("ID Width: %0d bits", AXI_ID_WIDTH);
        $display("Address Width: %0d bits (auto-calculated)", AXI_ADDR_WIDTH);
        $display("Strobe Width: %0d bits (auto-calculated)", AXI_STRB_WIDTH);
        $display("Total Test Count: %0d", TOTAL_TEST_COUNT);
        $display("Phase Test Count: %0d", PHASE_TEST_COUNT);
        $display("Test Count Address Size: %0d bytes", TEST_COUNT_ADDR_SIZE_BYTES);
        $display("================================");
    endfunction
    
endmodule

パラメータ設定の特徴

自動計算パラメータ: アドレス幅とストローブ幅は基本パラメータから自動計算
重み付き確率設定: 各バブル・ネゲート・バースト長の発生確率を重みで制御
シングルアクセス対応: バースト確率でシングルアクセス時のストローブ組み合わせを生成
設定の柔軟性: パラメータファイルで簡単に調整可能
デバッグ支援: パラメータ表示機能で設定内容を確認可能

このパラメータ設定により、テストベンチの動作を詳細に制御し、様々なテストシナリオに対応できます。

2.2 ハードウェア制御系

ハードウェア制御系では、クロックとリセットの生成・制御を行います。

2.2 ハードウェア制御系 - Sample Code

// クロック・リセット制御パラメータ
localparam CLK_PERIOD = 10;        // クロック周期 [ns]
localparam RESET_CYCLES = 5;       // リセット期間 [クロック数]
localparam CLK_HALF_PERIOD = CLK_PERIOD / 2;

// クロック・リセット信号
reg clk;
reg rst_n;

// クロック生成
initial begin
    clk = 0;
    forever #CLK_HALF_PERIOD clk = ~clk;
end

// リセット生成
initial begin
    rst_n = 0;
    repeat(RESET_CYCLES) @(posedge clk);
    #1
    rst_n = 1;
end

// クロック・リセット設定の表示
function void display_clock_reset_status;
    $display("Clock period: %0d ns", CLK_PERIOD);
    $display("Reset cycles: %0d", RESET_CYCLES);
endfunction

ハードウェア制御系の特徴

クロック生成: 指定された周期で安定したクロック信号を生成
リセット制御: 指定されたサイクル数のリセット期間を提供

2.3 テストデータ生成・期待値生成・制御系

テストデータ生成・制御系では、DUTに与えるスティミュラスの生成と制御を行います。

2.3.1 テストシナリオ制御

テストシナリオの制御を行います。期待値生成の確認、リセット解除の確認、フェーズ制御を含みます。

// テストデータ生成完了フラグ
logic generate_stimulus_expected_done = 1'b0;

// フェーズ制御用信号
logic [7:0] current_phase = 8'd0;

// フェーズ開始信号（各チャネル用）
logic write_addr_phase_start = 1'b0;
logic read_addr_phase_start = 1'b0;
logic write_data_phase_start = 1'b0;
logic read_data_phase_start = 1'b0;

// フェーズ完了信号（各チャネル用）
logic write_addr_phase_done = 1'b0;
logic read_addr_phase_done = 1'b0;
logic write_data_phase_done = 1'b0;
logic read_data_phase_done = 1'b0;

// フェーズ完了信号のラッチ（各チャネル用）
logic write_addr_phase_done_latched = 1'b0;
logic read_addr_phase_done_latched = 1'b0;
logic write_data_phase_done_latched = 1'b0;
logic read_data_phase_done_latched = 1'b0;

// フェーズ完了信号のラッチ回路
always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        // リセット中は初期化
        write_addr_phase_done_latched <= 1'b0;
        read_addr_phase_done_latched <= 1'b0;
        write_data_phase_done_latched <= 1'b0;
        read_data_phase_done_latched <= 1'b0;
    end else begin
        // パルス信号をラッチ
        if (write_addr_phase_done) write_addr_phase_done_latched <= 1'b1;
        if (read_addr_phase_done) read_addr_phase_done_latched <= 1'b1;
        if (write_data_phase_done) write_data_phase_done_latched <= 1'b1;
        if (read_data_phase_done) read_data_phase_done_latched <= 1'b1;
    end
end

// テストシナリオ制御
initial begin
    // 初期化
    current_phase = 8'd0;
    write_addr_phase_start = 1'b0;
    read_addr_phase_start = 1'b0;
    write_data_phase_start = 1'b0;
    read_data_phase_start = 1'b0;
    
    // 期待値生成完了の確認
    wait(generate_stimulus_expected_done);
    $display("Phase %0d: Stimulus and Expected Values Generation Confirmed", current_phase);
    
    // リセット解除の確認
    wait(rst_n);
    $display("Phase %0d: Reset Deassertion Confirmed", current_phase);

    // 2クロック待ってからフェーズ開始信号をアサート
    repeat(2) @(posedge clk);
    #1        
    // 各チャネルのフェーズ開始信号を1クロックアサート
    write_addr_phase_start = 1'b1;
    write_data_phase_start = 1'b1;
        
    // 次のクロックで開始信号をクリア
    @(posedge clk);
    #1        
    write_addr_phase_start = 1'b0;
    write_data_phase_start = 1'b0;

    // 全チャネルのフェーズ完了を待機（ラッチした信号を使用）
    wait(write_addr_phase_done_latched && write_data_phase_done_latched);

    $display("Phase %0d: All Channels Completed", current_phase);

    @(posedge clk);
    #1        
    // ラッチした信号をクリア
    write_addr_phase_done_latched = 1'b0;
    write_data_phase_done_latched = 1'b0;

    current_phase = current_phase + 8'd1;

    // フェーズ制御ループ
    for (int phase = 0; phase < (TOTAL_TEST_COUNT / PHASE_TEST_COUNT) - 1; phase++) begin
        @(posedge clk);
        #1        
        // 各チャネルのフェーズ開始信号を1クロックアサート
        write_addr_phase_start = 1'b1;
        read_addr_phase_start = 1'b1;
        write_data_phase_start = 1'b1;
        read_data_phase_start = 1'b1;
        
        // 次のクロックで開始信号をクリア
        @(posedge clk);
        #1
        write_addr_phase_start = 1'b0;
        read_addr_phase_start = 1'b0;
        write_data_phase_start = 1'b0;
        read_data_phase_start = 1'b0;
        
        // 全チャネルのフェーズ完了を待機（ラッチした信号を使用）
        wait(write_addr_phase_done_latched && read_addr_phase_done_latched && 
             write_data_phase_done_latched && read_data_phase_done_latched);
        
        $display("Phase %0d: All Channels Completed", current_phase);
        
        @(posedge clk);
        #1        
        // ラッチした信号をクリア
        write_addr_phase_done_latched = 1'b0;
        read_addr_phase_done_latched = 1'b0;
        write_data_phase_done_latched = 1'b0;
        read_data_phase_done_latched = 1'b0;
        
        // 次のフェーズに移行
        current_phase = current_phase + 8'd1;
    end
    @(posedge clk);
    #1        
    // 各チャネルのフェーズ開始信号を1クロックアサート
    read_addr_phase_start = 1'b1;
    read_data_phase_start = 1'b1;
        
    // 次のクロックで開始信号をクリア
    @(posedge clk);
    #1
    read_addr_phase_start = 1'b0;
    read_data_phase_start = 1'b0;
        
    // 全チャネルのフェーズ完了を待機（ラッチした信号を使用）
    wait(read_addr_phase_done_latched && write_data_phase_done_latched);
        
    $display("Phase %0d: All Channels Completed", current_phase);
        
    @(posedge clk);
    #1        
    // ラッチした信号をクリア
    read_addr_phase_done_latched = 1'b0;
    read_data_phase_done_latched = 1'b0;
    
    // 全フェーズ完了
    $display("All Phases Completed. Test Scenario Finished.");
    $finish;
end

2.3.2 時間0でのペイロードと期待値生成

Writeアドレスチャネル、Writeデータチャネル、Readアドレスチャネルの全てのペイロードを時間0で生成します。

// 時間0でのペイロード生成
initial begin
    // Writeアドレスチャネルのペイロードを先に生成
    generate_write_addr_payloads();
    generate_write_addr_payloads_with_stall();
    
    // Writeデータチャネルのペイロードを生成
    generate_write_data_payloads();
    generate_write_data_payloads_with_stall();
    
    // Readアドレスチャネルのペイロードを生成
    generate_read_addr_payloads();
    generate_read_addr_payloads_with_stall();
    
    // Readデータチャネルの期待値を生成
    generate_read_data_expected();
    
    // Writeレスポンスチャネルの期待値を生成
    generate_write_resp_expected();
    
    $display("Payloads and Expected Values Generated:");
    $display("  Write Address - Basic: %0d, Stall: %0d", 
             write_addr_payloads.size(), write_addr_payloads_with_stall.size());
    $display("  Write Data - Basic: %0d, Stall: %0d", 
             write_data_payloads.size(), write_data_payloads_with_stall.size());
    $display("  Read Address - Basic: %0d, Stall: %0d", 
             read_addr_payloads.size(), read_addr_payloads_with_stall.size());
    $display("  Read Data Expected - %0d", read_data_expected.size());
    $display("  Write Response Expected - %0d", write_resp_expected.size());
    
    // 1単位時間待ってから完了フラグを設定
    #1;
    generate_stimulus_expected_done = 1'b1;
end

2.3.3 Writeアドレスチャネルのテストデータ生成

Writeアドレスチャネルのペイロードデータを時間0で生成し、associated arrayに格納します。

// Writeアドレスチャネルのペイロード構造体
typedef struct {
    int                         test_count; // テストカウント（配列インデックスと一致）
    logic [AXI_ADDR_WIDTH-1:0] addr;      // アドレス
    logic [1:0]                 burst;     // バーストタイプ
    logic [2:0]                 size;      // バーストサイズ
    logic [AXI_ID_WIDTH-1:0]    id;        // トランザクションID
    logic [7:0]                 len;       // バースト長
    logic                       valid;     // 有効信号
    int                         phase;     // フェーズ番号
} write_addr_payload_t;

// Writeアドレスチャネルのペイロード配列（ストールなし）
write_addr_payload_t write_addr_payloads[int];

// Writeアドレスチャネルのペイロード配列（ストールあり）
write_addr_payload_t write_addr_payloads_with_stall[int];

// 基本ペイロード生成関数
function automatic void generate_write_addr_payloads();
    int test_count = 0;  // テストカウント（アドレス1回で1インクリメント）
    
    // 各バースト設定に対してペイロードを生成
    foreach (burst_config_weights[i]) begin
        burst_config_t config = burst_config_weights[i];
        
        // 設定された重み分のペイロードを生成
        for (int weight_count = 0; weight_count < config.weight; weight_count++) begin
            // バースト長をランダムに選択（burst_config_weightsの使用例に従う）
            int selected_length = $urandom_range(config.length_min, config.length_max);
            string selected_type = config.burst_type;
            
            // フェーズを計算（テストカウント/PHASE_TEST_COUNT）
            int phase = test_count / PHASE_TEST_COUNT;
            
            // 1. まず、TEST_COUNT_ADDR_SIZE_BYTES/4の範囲で乱数を発生
            logic [AXI_ADDR_WIDTH-1:0] random_offset = $urandom_range(0, TEST_COUNT_ADDR_SIZE_BYTES / 4 - 1);
            
            // 2. これをアドレス境界に合わせる
            int burst_size_bytes = (selected_length + 1) * (AXI_DATA_WIDTH / 8);
            logic [AXI_ADDR_WIDTH-1:0] aligned_offset = align_address_to_boundary(random_offset, burst_size_bytes, selected_type);
            
            // 3. 最後にTEST_COUNT_ADDR_SIZE_BYTES*phaseを足す
            logic [AXI_ADDR_WIDTH-1:0] base_addr = aligned_offset + (phase * TEST_COUNT_ADDR_SIZE_BYTES);
            
            // ペイロードを生成
            write_addr_payloads[test_count] = '{
                test_count: test_count,
                addr: base_addr,
                burst: get_burst_type_value(selected_type),
                size: $clog2(AXI_DATA_WIDTH / 8),
                id: $urandom_range(0, (1 << AXI_ID_WIDTH) - 1),
                len: selected_length,
                valid: 1'b1,
                phase: phase
            };
            
            test_count++;  // テストカウントをインクリメント
        end
    end
    
endfunction

// ストール込みペイロード生成関数
function automatic void generate_write_addr_payloads_with_stall();
    int stall_index = 0;
    
    // 基本ペイロードをコピーし、ストールを挿入
    foreach (write_addr_payloads[i]) begin
        // ストールなしのペイロードをコピー
        write_addr_payloads_with_stall[stall_index] = write_addr_payloads[i];
        stall_index++;
        
        // ストールを挿入（重み付き乱数で決定）
        int[] stall_weights = extract_weights_generic(write_addr_bubble_weights, write_addr_bubble_weights.size());
        int stall_total = calculate_total_weight_generic(stall_weights);
        int stall_index_selected = generate_weighted_random_index(stall_weights, stall_total);
        
        int stall_cycles = $urandom_range(
            write_addr_bubble_weights[stall_index_selected].cyc_cnt_start,
            write_addr_bubble_weights[stall_index_selected].cyc_cnt_end
        );
        
        // ストールサイクル分のペイロードを挿入
        for (int stall = 0; stall < stall_cycles; stall++) begin
            write_addr_payloads_with_stall[stall_index] = '{
                test_count: -1,  // ストール時は無効なテストカウント
                addr: 0,
                burst: 2'b00,
                size: 0,
                id: 0,
                len: 0,
                valid: 1'b0,
                phase: -1  // ストール時は無効なフェーズ番号
            };
            stall_index++;
        end
    end
endfunction

#### 2.3.4 Readアドレスチャネルのテストデータ生成

Readアドレスチャネルのペイロードデータを時間0で生成し、associated arrayに格納します。Write用の配列から必要な信号の値をコピーして作成します。

```verilog
// Readアドレスチャネルのペイロード構造体
typedef struct {
    int                         test_count; // テストカウント（配列インデックスと一致）
    logic [AXI_ADDR_WIDTH-1:0] addr;      // アドレス
    logic [1:0]                 burst;     // バーストタイプ
    logic [2:0]                 size;      // バーストサイズ
    logic [AXI_ID_WIDTH-1:0]    id;        // トランザクションID
    logic [7:0]                 len;       // バースト長
    logic                       valid;     // 有効信号
    int                         phase;     // フェーズ番号
} read_addr_payload_t;

// Readアドレスチャネルのペイロード配列（ストールなし）
read_addr_payload_t read_addr_payloads[int];

// Readアドレスチャネルのペイロード配列（ストールあり）
read_addr_payload_t read_addr_payloads_with_stall[int];

// Readアドレスチャネルのペイロード生成関数
function automatic void generate_read_addr_payloads();
    int test_count = 0;  // テストカウント（アドレス1回で1インクリメント）
    
    // Writeアドレスチャネルの配列から必要な信号の値をコピー
    foreach (write_addr_payloads[i]) begin
        write_addr_payload_t write_payload = write_addr_payloads[i];
        
        // ペイロードを生成（Write用からコピー）
        read_addr_payloads[test_count] = '{
            test_count: write_payload.test_count,
            addr: write_payload.addr,
            burst: write_payload.burst,
            size: write_payload.size,
            id: write_payload.id,
            len: write_payload.len,
            valid: write_payload.valid,
            phase: write_payload.phase
        };
        
        test_count++;
    end
endfunction

// Readアドレスチャネルのストール込みペイロード生成関数
function automatic void generate_read_addr_payloads_with_stall();
    int stall_index = 0;
    
    // 基本ペイロードをコピーし、ストールを挿入
    foreach (read_addr_payloads[i]) begin
        // ストールなしのペイロードをコピー
        read_addr_payloads_with_stall[stall_index] = read_addr_payloads[i];
        stall_index++;
        
        // ストールを挿入（重み付き乱数で決定）
        int[] stall_weights = extract_weights_generic(read_addr_bubble_weights, read_addr_bubble_weights.size());
        int stall_total = calculate_total_weight_generic(stall_weights);
        int stall_index_selected = generate_weighted_random_index(stall_weights, stall_total);
        
        int stall_cycles = $urandom_range(
            read_addr_bubble_weights[stall_index_selected].cyc_cnt_start,
            read_addr_bubble_weights[stall_index_selected].cyc_cnt_end
        );
        
        // ストールサイクル分のペイロードを挿入
        for (int stall = 0; stall < stall_cycles; stall++) begin
            read_addr_payloads_with_stall[stall_index] = '{
                test_count: -1,  // ストール時は無効なテストカウント
                addr: 0,
                burst: 2'b00,
                size: 0,
                id: 0,
                len: 0,
                valid: 1'b0,
                phase: -1  // ストール時は無効なフェーズ番号
            };
            stall_index++;
        end
    end
endfunction

// バーストタイプの値を取得する関数
function automatic logic [1:0] get_burst_type_value(string burst_type);
    case (burst_type)
        "FIXED": return 2'b00;
        "INCR":  return 2'b01;
        "WRAP":  return 2'b10;
        default: return 2'b01; // デフォルトはINCR
    endcase
endfunction

// アドレスを境界に合わせる関数
function automatic logic [AXI_ADDR_WIDTH-1:0] align_address_to_boundary(
    input logic [AXI_ADDR_WIDTH-1:0] address,
    input int burst_size_bytes,
    input string burst_type
);
    logic [AXI_ADDR_WIDTH-1:0] aligned_addr = address;
    
    case (burst_type)
        "WRAP": begin
            // WRAP転送の場合：バーストサイズの倍数に調整
            int wrap_boundary = burst_size_bytes;
            aligned_addr = (address / wrap_boundary) * wrap_boundary;
        end
        "INCR", "FIXED": begin
            // INCR/FIXED転送の場合：バス幅のサイズで最下位を0固定
            int bus_width_bytes = AXI_DATA_WIDTH / 8;
            aligned_addr = (address / bus_width_bytes) * bus_width_bytes;
        end
        default: begin
            // デフォルト：バス幅のサイズで最下位を0固定
            int bus_width_bytes = AXI_DATA_WIDTH / 8;
            aligned_addr = (address / bus_width_bytes) * bus_width_bytes;
        end
    endcase
    
    return aligned_addr;
endfunction

// FIXED転送用のSTROBEパターン生成関数
function automatic logic [AXI_STRB_WIDTH-1:0] generate_fixed_strobe_pattern(
    input logic [AXI_ADDR_WIDTH-1:0] address,
    input logic [2:0] size,
    input int data_width
);
    logic [AXI_STRB_WIDTH-1:0] strobe_pattern = 0;
    int bus_width_bytes = data_width / 8;
    int burst_size_bytes = (1 << size);
    
    // アドレスの下位ビットからバーストサイズ分のSTROBEを有効化
    // アドレスの下位ビットがバーストサイズの境界に合わせて調整される
    int addr_offset = address % bus_width_bytes;  // バス幅内でのオフセット（バイト単位）
    int strobe_start = addr_offset;               // STROBE開始位置（バイト単位）
    int strobe_end = strobe_start + burst_size_bytes - 1;  // STROBE終了位置（バイト単位）
    
    // アドレスとサイズの整合性チェック
    if (strobe_end >= bus_width_bytes) begin
        $error("FIXED transfer error: Address 0x%h with size %0d exceeds bus width %0d bytes. strobe_end=%0d", 
               address, burst_size_bytes, bus_width_bytes, strobe_end);
        $finish;
    end
    
    // STROBEパターンを生成（バイト単位）
    for (int byte = strobe_start; byte <= strobe_end; byte++) begin
        strobe_pattern[byte] = 1'b1;
    end
    
    return strobe_pattern;
endfunction

2.3.5 Writeデータチャネルのテストデータ生成

Writeデータチャネルのペイロードデータを時間0で生成し、associated arrayに格納します。Writeアドレスチャネルのペイロードと連携して、適切なデータとストローブを生成します。

// Writeデータチャネルのペイロード構造体
typedef struct {
    int                         test_count; // テストカウント（配列インデックスと一致）
    logic [AXI_DATA_WIDTH-1:0] data;       // データ
    logic [AXI_STRB_WIDTH-1:0] strb;       // ストローブ
    logic                       last;       // 最後の転送フラグ
    logic                       valid;      // 有効信号
    int                         phase;      // フェーズ番号
} write_data_payload_t;

// Writeデータチャネルのペイロード配列（ストールなし）
write_data_payload_t write_data_payloads[int];

// Writeデータチャネルのペイロード配列（ストールあり）
write_data_payload_t write_data_payloads_with_stall[int];

// Writeデータチャネルのペイロード生成関数
function automatic void generate_write_data_payloads();
    int test_count = 0;  // テストカウント（アドレス1回で1インクリメント）
    
    // Writeアドレスチャネルの配列からデータペイロードを生成
    foreach (write_addr_payloads[i]) begin
        write_addr_payload_t addr_payload = write_addr_payloads[i];
        
        // バースト長に応じてデータペイロードを生成
        int burst_length = addr_payload.len + 1;
        
        for (int burst_idx = 0; burst_idx < burst_length; burst_idx++) begin
            // データを生成（ランダム値）
            logic [AXI_DATA_WIDTH-1:0] random_data = $urandom();
            
            // ストローブを生成（バースト長とバーストタイプに応じて）
            logic [AXI_STRB_WIDTH-1:0] strobe_pattern;
            if (addr_payload.burst == 2'b00) begin // FIXED
                // FIXED転送：アドレスとSIZEに基づいてSTROBEの位置を決定
                strobe_pattern = generate_fixed_strobe_pattern(
                    addr_payload.addr, 
                    addr_payload.size, 
                    AXI_DATA_WIDTH
                );
            end else begin // INCR, WRAP
                // INCR/WRAP転送：全てのストローブを有効
                strobe_pattern = {AXI_STRB_WIDTH{1'b1}};
            end
            
            // データをSTROBEでマスク（使用していないビットを0に）
            // STROBEはバイト単位なので、各バイトの8ビットに拡張してマスク
            logic [AXI_DATA_WIDTH-1:0] strobe_mask = 0;
            for (int byte = 0; byte < AXI_STRB_WIDTH; byte++) begin
                if (strobe_pattern[byte]) begin
                    // 該当バイトの8ビットを1に設定
                    strobe_mask[byte*8 +: 8] = 8'hFF;
                end
            end
            logic [AXI_DATA_WIDTH-1:0] masked_data = random_data & strobe_mask;
            
            // 最後の転送フラグを設定
            logic is_last = (burst_idx == burst_length - 1);
            
            // ペイロードを生成
            write_data_payloads[test_count] = '{
                test_count: addr_payload.test_count,
                data: masked_data,
                strb: strobe_pattern,
                last: is_last,
                valid: 1'b1,
                phase: addr_payload.phase
            };
            
            test_count++;
        end
    end
endfunction

// Writeデータチャネルのストール込みペイロード生成関数
function automatic void generate_write_data_payloads_with_stall();
    int stall_index = 0;
    
    // 基本ペイロードをコピーし、ストールを挿入
    foreach (write_data_payloads[i]) begin
        // ストールなしのペイロードをコピー
        write_data_payloads_with_stall[stall_index] = write_data_payloads[i];
        stall_index++;
        
        // ストールを挿入（重み付き乱数で決定）
        int[] stall_weights = extract_weights_generic(write_data_bubble_weights, write_data_bubble_weights.size());
        int stall_total = calculate_total_weight_generic(stall_weights);
        int stall_index_selected = generate_weighted_random_index(stall_weights, stall_total);
        
        int stall_cycles = $urandom_range(
            write_data_bubble_weights[stall_index_selected].cyc_cnt_start,
            write_data_bubble_weights[stall_index_selected].cyc_cnt_end
        );
        
        // ストールサイクル分のペイロードを挿入
        for (int stall = 0; stall < stall_cycles; stall++) begin
            write_data_payloads_with_stall[stall_index] = '{
                test_count: -1,  // ストール時は無効なテストカウント
                data: 0,
                strb: 0,
                last: 1'b0,
                valid: 1'b0,
                phase: -1  // ストール時は無効なフェーズ番号
            };
            stall_index++;
        end
    end
endfunction


#### 2.3.6 Writeアドレスチャネルの制御回路

```verilog
// Writeアドレスチャネルの制御信号
logic write_addr_phase_done = 1'b0;
logic write_addr_phase_busy = 1'b0;

// Writeアドレスチャネルの出力信号
logic [AXI_ADDR_WIDTH-1:0] axi_aw_addr;
logic [1:0]                axi_aw_burst;
logic [2:0]                axi_aw_size;
logic [AXI_ID_WIDTH-1:0]   axi_aw_id;
logic [7:0]                axi_aw_len;
logic                      axi_aw_valid;

// Writeアドレスチャネルの制御状態
typedef enum logic [1:0] {
    WRITE_ADDR_IDLE,        // 待機状態
    WRITE_ADDR_ACTIVE,      // アクティブ状態（ストール処理も含む）
    WRITE_ADDR_FINISH       // 終了処理状態
} write_addr_state_t;

write_addr_state_t write_addr_state = WRITE_ADDR_IDLE;

// Writeアドレスチャネルの制御用変数
int write_addr_phase_counter = 0;     // 制御用：Phase内のアドレスカウント
int write_addr_payload_index = 0;     // 制御用：ペイロード配列のインデックス

// Writeアドレスチャネルのレポート用変数
int report_write_addr_stall_cycles = 0;  // レポート用：累積ストールサイクル数

// Writeアドレスチャネルのデバッグ用変数
int debug_write_addr_current_test_count = 0;  // デバッグ用：現在のテストカウント

// Writeアドレスチャネルの制御回路
always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        // リセット中は停止、初期値0
        write_addr_state <= WRITE_ADDR_IDLE;
        write_addr_phase_done <= 1'b0;
        write_addr_phase_busy <= 1'b0;
        write_addr_test_counter <= 0;
        write_addr_payload_index <= 0;
        report_write_addr_stall_cycles <= 0;
        debug_write_addr_current_test_count <= 0;
        
        // 出力信号を初期化
        axi_aw_addr <= 0;
        axi_aw_burst <= 0;
        axi_aw_size <= 0;
        axi_aw_id <= 0;
        axi_aw_len <= 0;
        axi_aw_valid <= 1'b0;
        
    end else begin
        case (write_addr_state)
            WRITE_ADDR_IDLE: begin
                // 待機状態：phase_startが1になるまで待機
                // phase_doneを0にリセット
                write_addr_phase_done <= 1'b0;
                
                if (write_addr_phase_start) begin
                    write_addr_state <= WRITE_ADDR_ACTIVE;
                    write_addr_phase_busy <= 1'b1;
                    write_addr_payload_index <= 0;
                    write_addr_phase_counter <= 0;
                end
            end
            
            WRITE_ADDR_ACTIVE: begin
                // アクティブ状態：ペイロードを順次出力
                if (write_addr_payload_index < write_addr_payloads_with_stall.size()) begin
                    write_addr_payload_t payload = write_addr_payloads_with_stall[write_addr_payload_index];
                    
                    // Readyがアサートされている場合のみペイロードを出力・更新
                    if (axi_aw_ready) begin
                        // ペイロードを出力
                        axi_aw_addr <= payload.addr;
                        axi_aw_burst <= payload.burst;
                        axi_aw_size <= payload.size;
                        axi_aw_id <= payload.id;
                        axi_aw_len <= payload.len;
                        axi_aw_valid <= payload.valid;
                        
                        // デバッグ用：テストカウントを読み出し
                        debug_write_addr_current_test_count = payload.test_count;
                        
                        // 次のペイロードへ
                        write_addr_payload_index <= write_addr_payload_index + 1;
                        
                        // 有効なペイロードの場合のみカウンタをインクリメント
                        if (payload.valid) begin
                            write_addr_phase_counter <= write_addr_phase_counter + 1;
                        end
                    end else begin
                        // Readyがネゲートされている場合は現在のペイロードを保持
                        // ストールカウンタをインクリメント
                        report_write_addr_stall_cycles <= report_write_addr_stall_cycles + 1;
                    end
                end else begin
                    // 配列の最後に到達：終了処理ステートに移行
                    write_addr_state <= WRITE_ADDR_FINISH;
                    write_addr_phase_done <= 1'b1;
                    
                    // 出力信号をクリア
                    axi_aw_valid <= 1'b0;
                end
            end
            
            WRITE_ADDR_FINISH: begin
                // 終了処理状態：phase_doneをネゲートしてからIDLEに移行
                write_addr_phase_done <= 1'b0;
                write_addr_phase_busy <= 1'b0;
                write_addr_state <= WRITE_ADDR_IDLE;
            end
        endcase
    end
end

// フェーズ完了の検出と次のフェーズの開始
always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        // リセット中は何もしない
    end else begin
        // フェーズ完了を検出したら、次のフェーズの準備
        if (write_addr_phase_done) begin
            write_addr_phase_done <= 1'b0;
            
            // PHASE_TEST_COUNT回数実行したかチェック
            if (write_addr_phase_counter >= PHASE_TEST_COUNT) begin
                // フェーズ完了：次のフェーズ待ち
                $display("Write Address Phase Counter %0d completed. Total transfers: %0d", 
                         write_addr_phase_counter, write_addr_phase_counter);
            end else begin
                // フェーズ途中：次のフェーズを開始
                $display("Write Address Phase Counter %0d started. Target: %0d", 
                         write_addr_phase_counter + 1, PHASE_TEST_COUNT);
            end
        end
    end
end

// デバッグ用の監視信号
always @(posedge clk) begin
    if (axi_aw_valid && axi_aw_ready) begin
        // 現在のペイロードの情報を取得
        write_addr_payload_t current_payload = write_addr_payloads_with_stall[write_addr_payload_index];
        $display("Write Address Transfer: TestCount=%0d, Addr=0x%h, Burst=%b, Size=%0d, ID=%0d, Len=%0d, Phase=%0d", 
                 current_payload.test_count, axi_aw_addr, axi_aw_burst, axi_aw_size, axi_aw_id, axi_aw_len, current_payload.phase);
    end
end

2.3.7 Readアドレスチャネルの制御回路

Readアドレスチャネルの制御回路を実装します。Writeアドレスチャネルと同様の構造で、DUTにスティミュラスを与える制御を行います。

// Readアドレスチャネルの制御信号
logic read_addr_phase_done = 1'b0;
logic read_addr_phase_busy = 1'b0;

// Readアドレスチャネルの出力信号
logic [AXI_ADDR_WIDTH-1:0] axi_ar_addr;
logic [1:0]                axi_ar_burst;
logic [2:0]                axi_ar_size;
logic [AXI_ID_WIDTH-1:0]   axi_ar_id;
logic [7:0]                axi_ar_len;
logic                      axi_ar_valid;

// Readアドレスチャネルの制御状態
typedef enum logic [1:0] {
    READ_ADDR_IDLE,        // 待機状態
    READ_ADDR_ACTIVE,      // アクティブ状態（ストール処理も含む）
    READ_ADDR_FINISH       // 終了処理状態
} read_addr_state_t;

read_addr_state_t read_addr_state = READ_ADDR_IDLE;

// Readアドレスチャネルの制御用変数
int read_addr_phase_counter = 0;     // 制御用：Phase内のアドレスカウント
int read_addr_payload_index = 0;     // 制御用：ペイロード配列のインデックス

// Readアドレスチャネルのレポート用変数
int report_read_addr_stall_cycles = 0;  // レポート用：累積ストールサイクル数

// Readアドレスチャネルのデバッグ用変数
int debug_read_addr_current_test_count = 0;  // デバッグ用：現在のテストカウント

// Readアドレスチャネルの制御回路
always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        // リセット中は停止、初期値0
        read_addr_state <= READ_ADDR_IDLE;
        read_addr_phase_done <= 1'b0;
        read_addr_phase_busy <= 1'b0;
        read_addr_phase_counter <= 0;
        read_addr_payload_index <= 0;
        report_read_addr_stall_cycles <= 0;
        debug_read_addr_current_test_count <= 0;
        
        // 出力信号を初期化
        axi_ar_addr <= 0;
        axi_ar_burst <= 0;
        axi_ar_size <= 0;
        axi_ar_id <= 0;
        axi_ar_len <= 0;
        axi_ar_valid <= 1'b0;
        
    end else begin
        case (read_addr_state)
            READ_ADDR_IDLE: begin
                // 待機状態：phase_startが1になるまで待機
                // phase_doneを0にリセット
                read_addr_phase_done <= 1'b0;
                
                if (read_addr_phase_start) begin
                    read_addr_state <= READ_ADDR_ACTIVE;
                    read_addr_phase_busy <= 1'b1;
                    read_addr_payload_index <= 0;
                    read_addr_phase_counter <= 0;
                end
            end
            
            READ_ADDR_ACTIVE: begin
                // アクティブ状態：ペイロードを順次出力
                if (read_addr_payload_index < read_addr_payloads_with_stall.size()) begin
                    read_addr_payload_t payload = read_addr_payloads_with_stall[read_addr_payload_index];
                    
                    // Readyがアサートされている場合のみペイロードを出力・更新
                    if (axi_ar_ready) begin
                        // ペイロードを出力
                        axi_ar_addr <= payload.addr;
                        axi_ar_burst <= payload.burst;
                        axi_ar_size <= payload.size;
                        axi_ar_id <= payload.id;
                        axi_ar_len <= payload.len;
                        axi_ar_valid <= payload.valid;
                        
                        // デバッグ用：テストカウントを読み出し
                        debug_read_addr_current_test_count = payload.test_count;
                        
                        // 次のペイロードへ
                        read_addr_payload_index <= read_addr_payload_index + 1;
                        
                        // 有効なペイロードの場合のみカウンタをインクリメント
                        if (payload.valid) begin
                            read_addr_phase_counter <= read_addr_phase_counter + 1;
                        end
                    end else begin
                        // Readyがネゲートされている場合は現在のペイロードを保持
                        // ストールカウンタをインクリメント
                        report_read_addr_stall_cycles <= report_read_addr_stall_cycles + 1;
                    end
                end else begin
                    // 配列の最後に到達：終了処理ステートに移行
                    read_addr_state <= READ_ADDR_FINISH;
                    read_addr_phase_done <= 1'b1;
                    
                    // 出力信号をクリア
                    axi_ar_valid <= 1'b0;
                end
            end
            
            READ_ADDR_FINISH: begin
                // 終了処理状態：phase_doneをネゲートしてからIDLEに移行
                read_addr_phase_done <= 1'b0;
                read_addr_phase_busy <= 1'b0;
                read_addr_state <= READ_ADDR_IDLE;
            end
        endcase
    end
end

// フェーズ完了の検出と次のフェーズの開始
always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        // リセット中は何もしない
    end else begin
        // フェーズ完了を検出したら、次のフェーズの準備
        if (read_addr_phase_done) begin
            read_addr_phase_done <= 1'b0;
            
            // PHASE_TEST_COUNT回数実行したかチェック
            if (read_addr_phase_counter >= PHASE_TEST_COUNT) begin
                // フェーズ完了：次のフェーズ待ち
                $display("Read Address Phase Counter %0d completed. Total transfers: %0d", 
                         read_addr_phase_counter, read_addr_phase_counter);
            end else begin
                // フェーズ途中：次のフェーズを開始
                $display("Read Address Phase Counter %0d started. Target: %0d", 
                         read_addr_phase_counter + 1, PHASE_TEST_COUNT);
            end
        end
    end
end

// デバッグ用の監視信号
always @(posedge clk) begin
    if (axi_ar_valid && axi_ar_ready) begin
        // 現在のペイロードの情報を取得
        read_addr_payload_t current_payload = read_addr_payloads_with_stall[read_addr_payload_index];
        $display("Read Address Transfer: TestCount=%0d, Addr=0x%h, Burst=%b, Size=%0d, ID=%0d, Len=%0d, Phase=%0d", 
                 current_payload.test_count, axi_ar_addr, axi_ar_burst, axi_ar_size, axi_ar_id, axi_ar_len, current_payload.phase);
    end
end

#### 2.3.8 Writeデータチャネルの制御回路

Writeデータチャネルの制御回路を実装します。Writeアドレスチャネルと連携して、適切なタイミングでデータとストローブを出力します。

```verilog
// Writeデータチャネルの制御信号
logic write_data_phase_done = 1'b0;
logic write_data_phase_busy = 1'b0;

// Writeデータチャネルの出力信号
logic [AXI_DATA_WIDTH-1:0] axi_w_data;
logic [AXI_STRB_WIDTH-1:0] axi_w_strb;
logic                       axi_w_last;
logic                       axi_w_valid;

// Writeデータチャネルの制御状態
typedef enum logic [1:0] {
    WRITE_DATA_IDLE,        // 待機状態
    WRITE_DATA_ACTIVE,      // アクティブ状態（ストール処理も含む）
    WRITE_DATA_FINISH       // 終了処理状態
} write_data_state_t;

write_data_state_t write_data_state = WRITE_DATA_IDLE;

// Writeデータチャネルの制御用変数
int write_data_phase_counter = 0;     // 制御用：Phase内のデータカウント
int write_data_payload_index = 0;     // 制御用：ペイロード配列のインデックス

// Writeデータチャネルのレポート用変数
int report_write_data_stall_cycles = 0;  // レポート用：累積ストールサイクル数

// Writeデータチャネルのデバッグ用変数
int debug_write_data_current_test_count = 0;  // デバッグ用：現在のテストカウント

// Writeデータチャネルの制御回路
always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        // リセット中は停止、初期値0
        write_data_state <= WRITE_DATA_IDLE;
        write_data_phase_done <= 1'b0;
        write_data_phase_busy <= 1'b0;
        write_data_phase_counter <= 0;
        write_data_payload_index <= 0;
        report_write_data_stall_cycles <= 0;
        debug_write_data_current_test_count <= 0;
        
        // 出力信号を初期化
        axi_w_data <= 0;
        axi_w_strb <= 0;
        axi_w_last <= 1'b0;
        axi_w_valid <= 1'b0;
        
    end else begin
        case (write_data_state)
            WRITE_DATA_IDLE: begin
                // 待機状態：phase_startが1になるまで待機
                // phase_doneを0にリセット
                write_data_phase_done <= 1'b0;
                
                if (write_data_phase_start) begin
                    write_data_state <= WRITE_DATA_ACTIVE;
                    write_data_phase_busy <= 1'b1;
                    write_data_payload_index <= 0;
                    write_data_phase_counter <= 0;
                end
            end
            
            WRITE_DATA_ACTIVE: begin
                // アクティブ状態：ペイロードを順次出力
                if (write_data_payload_index < write_data_payloads_with_stall.size()) begin
                    write_data_payload_t payload = write_data_payloads_with_stall[write_data_payload_index];
                    
                    // Readyがアサートされている場合のみペイロードを出力・更新
                    if (axi_w_ready) begin
                        // ペイロードを出力
                        axi_w_data <= payload.data;
                        axi_w_strb <= payload.strb;
                        axi_w_last <= payload.last;
                        axi_w_valid <= payload.valid;
                        
                        // デバッグ用：テストカウントを読み出し
                        debug_write_data_current_test_count = payload.test_count;
                        
                        // 次のペイロードへ
                        write_data_payload_index <= write_data_payload_index + 1;
                        
                        // 有効なペイロードの場合のみカウンタをインクリメント
                        if (payload.valid) begin
                            write_data_phase_counter <= write_data_phase_counter + 1;
                        end
                    end else begin
                        // Readyがネゲートされている場合は現在のペイロードを保持
                        // ストールカウンタをインクリメント
                        report_write_data_stall_cycles <= report_write_data_stall_cycles + 1;
                    end
                end else begin
                    // 配列の最後に到達：終了処理ステートに移行
                    write_data_state <= WRITE_DATA_FINISH;
                    write_data_phase_done <= 1'b1;
                    
                    // 出力信号をクリア
                    axi_w_valid <= 1'b0;
                end
            end
            
            WRITE_DATA_FINISH: begin
                // 終了処理状態：phase_doneをネゲートしてからIDLEに移行
                write_data_phase_done <= 1'b0;
                write_data_phase_busy <= 1'b0;
                write_data_state <= WRITE_DATA_IDLE;
            end
        endcase
    end
end

// フェーズ完了の検出と次のフェーズの開始
always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        // リセット中は何もしない
    end else begin
        // フェーズ完了を検出したら、次のフェーズの準備
        if (write_data_phase_done) begin
            write_data_phase_done <= 1'b0;
            
            // PHASE_TEST_COUNT回数実行したかチェック
            if (write_data_phase_counter >= PHASE_TEST_COUNT) begin
                // フェーズ完了：次のフェーズ待ち
                $display("Write Data Phase Counter %0d completed. Total transfers: %0d", 
                         write_data_phase_counter, write_data_phase_counter);
            end else begin
                // フェーズ途中：次のフェーズを開始
                $display("Write Data Phase Counter %0d started. Target: %0d", 
                         write_data_phase_counter + 1, PHASE_TEST_COUNT);
            end
        end
    end
end

// デバッグ用の監視信号
always @(posedge clk) begin
    if (axi_w_valid && axi_w_ready) begin
        // 現在のペイロードの情報を取得
        write_data_payload_t current_payload = write_data_payloads_with_stall[write_data_payload_index];
        $display("Write Data Transfer: TestCount=%0d, Data=0x%h, Strb=%b, Last=%b, Phase=%0d", 
                 current_payload.test_count, axi_w_data, axi_w_strb, axi_w_last, current_payload.phase);
    end
end

2.3.9 Readデータチャネルの期待値生成

Readデータチャネルの期待値を生成し、associated arrayに格納します。Writeデータチャネルのペイロードと連携して、適切な期待値を生成します。

// Readデータチャネルの期待値構造体
typedef struct {
    int                         test_count; // テストカウント（配列インデックスと一致）
    logic [AXI_DATA_WIDTH-1:0] expected_data; // 期待値データ
    int                         phase;      // フェーズ番号
} read_data_expected_t;

// Readデータチャネルの期待値配列
read_data_expected_t read_data_expected[int];

// Readデータチャネルの期待値生成関数
function automatic void generate_read_data_expected();
    int test_count = 0;  // テストカウント（アドレス1回で1インクリメント）
    
    // Writeデータチャネルのペイロード配列から期待値を生成
    // write_data_payloadsには既にSTROBEでマスク済みのデータが格納されている
    foreach (write_data_payloads[i]) begin
        write_data_payload_t write_payload = write_data_payloads[i];
        
        if (write_payload.valid) begin
            // 有効なWriteペイロードの場合、対応するRead期待値を生成
            // Writeデータ（STROBEマスク済み）がそのままRead期待値になる
            read_data_expected[test_count] = '{
                test_count: write_payload.test_count,
                expected_data: write_payload.data,  // 既にマスク済みのデータ
                phase: write_payload.phase
            };
            
            test_count++;
        end
    end
    
    $display("Read Data Expected Values Generated: %0d", test_count);
endfunction

#### 2.3.10 Writeレスポンスチャネルの期待値生成

Writeレスポンスチャネルの期待値を生成し、associated arrayに格納します。Writeアドレスチャネルのペイロードと連携して、適切なレスポンス期待値を生成します。

```verilog
// Writeレスポンスチャネルの期待値構造体
typedef struct {
    int                         test_count; // テストカウント（配列インデックスと一致）
    logic [1:0]                expected_resp; // 期待値レスポンス（OKAY）
    logic [AXI_ID_WIDTH-1:0]   expected_id;   // 期待値ID
    int                         phase;         // フェーズ番号
} write_resp_expected_t;

// Writeレスポンスチャネルの期待値配列
write_resp_expected_t write_resp_expected[int];

// Writeレスポンスチャネルの期待値生成関数
function automatic void generate_write_resp_expected();
    int test_count = 0;  // テストカウント（アドレス1回で1インクリメント）
    
    // Writeアドレスチャネルのペイロード配列から期待値を生成
    foreach (write_addr_payloads[i]) begin
        write_addr_payload_t addr_payload = write_addr_payloads[i];
        
        if (addr_payload.valid) begin
            // 有効なWriteアドレスペイロードの場合、対応するレスポンス期待値を生成
            // 正常なWrite転送の場合、レスポンスは常にOKAY（2'b00）
            
            write_resp_expected[test_count] = '{
                test_count: addr_payload.test_count,
                expected_resp: 2'b00,  // 常にOKAY
                expected_id: addr_payload.id,  // Writeアドレスと同じID
                phase: addr_payload.phase
            };
            
            test_count++;
        end
    end
    
    $display("Write Response Expected Values Generated: %0d", test_count);
endfunction

#### 2.3.11 Readデータチャネルの制御回路

Readデータチャネルの制御回路を実装します。Readアドレスチャネルと連携して、適切なタイミングでデータを受信し、期待値と比較します。

```verilog
// Readデータチャネルの制御信号
logic read_data_phase_done = 1'b0;
logic read_data_phase_busy = 1'b0;

// Readデータチャネルの入力信号
logic [AXI_DATA_WIDTH-1:0] axi_r_data;
logic [1:0]                axi_r_resp;
logic                       axi_r_last;
logic                       axi_r_valid;
logic                       axi_r_ready;

// Readデータチャネルの制御状態
typedef enum logic [1:0] {
    READ_DATA_IDLE,        // 待機状態
    READ_DATA_ACTIVE,      // アクティブ状態（ストール処理も含む）
    READ_DATA_FINISH       // 終了処理状態
} read_data_state_t;

read_data_state_t read_data_state = READ_DATA_IDLE;

// Readデータチャネルの制御用変数
int read_data_phase_counter = 0;     // 制御用：Phase内のデータカウント
int read_data_payload_index = 0;     // 制御用：ペイロード配列のインデックス

// Readデータチャネルのレポート用変数
int report_read_data_stall_cycles = 0;  // レポート用：累積ストールサイクル数

// Readデータチャネルのデバッグ用変数
int debug_read_data_current_test_count = 0;  // デバッグ用：現在のテストカウント

// Readデータチャネルの制御回路
always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        // リセット中は停止、初期値0
        read_data_state <= READ_DATA_IDLE;
        read_data_phase_done <= 1'b0;
        read_data_phase_busy <= 1'b0;
        read_data_phase_counter <= 0;
        read_data_payload_index <= 0;
        report_read_data_stall_cycles <= 0;
        debug_read_data_current_test_count <= 0;
        
        // 出力信号を初期化
        axi_r_ready <= 1'b0;
        
    end else begin
        case (read_data_state)
            READ_DATA_IDLE: begin
                // 待機状態：phase_startが1になるまで待機
                // phase_doneを0にリセット
                read_data_phase_done <= 1'b0;
                
                if (read_data_phase_start) begin
                    read_data_state <= READ_DATA_ACTIVE;
                    read_data_phase_busy <= 1'b1;
                    read_data_payload_index <= 0;
                    read_data_phase_counter <= 0;
                    axi_r_ready <= 1'b1;  // Readデータ受信準備完了
                end
            end
            
            READ_DATA_ACTIVE: begin
                // アクティブ状態：データを受信して期待値と比較
                if (axi_r_valid && axi_r_ready) begin
                    // データを受信、期待値と比較
                    read_data_expected_t expected = read_data_expected[read_data_payload_index];
                    
                    // デバッグ用：テストカウントを読み出し
                    debug_read_data_current_test_count = expected.test_count;
                    
                    // データの比較と検証
                    if (axi_r_data !== expected.expected_data) begin
                        $error("Read Data Mismatch: TestCount=%0d, Expected=0x%h, Actual=0x%h, Phase=%0d", 
                               expected.test_count, expected.expected_data, axi_r_data, expected.phase);
                    end else begin
                        $display("Read Data Match: TestCount=%0d, Data=0x%h, Phase=%0d", 
                                expected.test_count, axi_r_data, expected.phase);
                    end
                    
                    // 次のペイロードへ
                    read_data_payload_index <= read_data_payload_index + 1;
                    
                    // 有効なデータの場合のみカウンタをインクリメント
                    if (expected.test_count >= 0) begin
                        read_data_phase_counter <= read_data_phase_counter + 1;
                    end
                    
                    // 配列の最後に到達したかチェック
                    if (read_data_payload_index >= read_data_expected.size() - 1) begin
                        read_data_state <= READ_DATA_FINISH;
                        read_data_phase_done <= 1'b1;
                        axi_r_ready <= 1'b0;
                    end
                end else if (!axi_r_ready) begin
                    // Readyがネゲートされている場合はストールカウンタをインクリメント
                    report_read_data_stall_cycles <= report_read_data_stall_cycles + 1;
                end
            end
            
            READ_DATA_FINISH: begin
                // 終了処理状態：phase_doneをネゲートしてからIDLEに移行
                read_data_phase_done <= 1'b0;
                read_data_phase_busy <= 1'b0;
                read_data_state <= READ_DATA_IDLE;
            end
        endcase
    end
end

// フェーズ完了の検出と次のフェーズの開始
always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        // リセット中は何もしない
    end else begin
        // フェーズ完了を検出したら、次のフェーズの準備
        if (read_data_phase_done) begin
            read_data_phase_done <= 1'b0;
            
            // PHASE_TEST_COUNT回数実行したかチェック
            if (read_data_phase_counter >= PHASE_TEST_COUNT) begin
                // フェーズ完了：次のフェーズ待ち
                $display("Read Data Phase Counter %0d completed. Total transfers: %0d", 
                         read_data_phase_counter, read_data_phase_counter);
            end else begin
                // フェーズ途中：次のフェーズを開始
                $display("Read Data Phase Counter %0d started. Target: %0d", 
                         read_data_phase_counter + 1, PHASE_TEST_COUNT);
            end
        end
    end
end

// デバッグ用の監視信号
always @(posedge clk) begin
    if (axi_r_valid && axi_r_ready) begin
        // 現在の期待値の情報を取得
        read_data_expected_t current_expected = read_data_expected[read_data_payload_index];
        $display("Read Data Transfer: TestCount=%0d, Data=0x%h, Resp=%b, Last=%b, Phase=%0d", 
                 current_expected.test_count, axi_r_data, axi_r_resp, axi_r_last, current_expected.phase);
    end
end

2.4 プロトコル検証系

プロトコル検証系では、AXI4仕様の準拠性を確認し、Ready/Validハンドシェイクの動作を検証します。

2.4.1 Readyネゲート時のペイロードホールド確認

Ready信号がネゲートされた時に、ペイロード（データ信号とValid信号を含む）が適切にホールドされているかを各チャネル毎に確認します。監視はリセット解除後から開始されます。

// プロトコル検証用の遅延信号
logic [AXI_ADDR_WIDTH-1:0] axi_aw_addr_delayed;
logic [1:0]                axi_aw_burst_delayed;
logic [2:0]                axi_aw_size_delayed;
logic [AXI_ID_WIDTH-1:0]   axi_aw_id_delayed;
logic [7:0]                axi_aw_len_delayed;
logic                      axi_aw_valid_delayed;

logic [AXI_ADDR_WIDTH-1:0] axi_ar_addr_delayed;
logic [1:0]                axi_ar_burst_delayed;
logic [2:0]                axi_ar_size_delayed;
logic [AXI_ID_WIDTH-1:0]   axi_ar_id_delayed;
logic [7:0]                axi_ar_len_delayed;
logic                      axi_ar_valid_delayed;

logic [AXI_DATA_WIDTH-1:0] axi_w_data_delayed;
logic [AXI_STRB_WIDTH-1:0] axi_w_strb_delayed;
logic                       axi_w_last_delayed;
logic                       axi_w_valid_delayed;

logic                       axi_r_ready_delayed;
logic                       axi_w_ready_delayed;

// 1クロック遅延回路
always_ff @(posedge clk) begin
    // Writeアドレスチャネル
    axi_aw_addr_delayed <= axi_aw_addr;
    axi_aw_burst_delayed <= axi_aw_burst;
    axi_aw_size_delayed <= axi_aw_size;
    axi_aw_id_delayed <= axi_aw_id;
    axi_aw_len_delayed <= axi_aw_len;
    axi_aw_valid_delayed <= axi_aw_valid;
    
    // Readアドレスチャネル
    axi_ar_addr_delayed <= axi_ar_addr;
    axi_ar_burst_delayed <= axi_ar_burst;
    axi_ar_size_delayed <= axi_ar_size;
    axi_ar_id_delayed <= axi_ar_id;
    axi_ar_len_delayed <= axi_ar_len;
    axi_ar_valid_delayed <= axi_ar_valid;
    
    // Writeデータチャネル
    axi_w_data_delayed <= axi_w_data;
    axi_w_strb_delayed <= axi_w_strb;
    axi_w_last_delayed <= axi_w_last;
    axi_w_valid_delayed <= axi_w_valid;
    
    // Ready信号
    axi_r_ready_delayed <= axi_r_ready;
    axi_w_ready_delayed <= axi_w_ready;
end

// Writeアドレスチャネルのペイロードホールド確認（リセット解除後に監視開始）
always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        // リセット中は監視しない
    end else begin
        if (!axi_aw_ready_delayed) begin
            // Readyがネゲートされている時にペイロードが変わっていないかチェック
            if (axi_aw_addr !== axi_aw_addr_delayed) begin
                $error("Write Address Channel: Address changed during Ready negated. Current: 0x%h, Delayed: 0x%h", 
                       axi_aw_addr, axi_aw_addr_delayed);
                $finish;
            end
            if (axi_aw_burst !== axi_aw_burst_delayed) begin
                $error("Write Address Channel: Burst changed during Ready negated. Current: %b, Delayed: %b", 
                       axi_aw_burst, axi_aw_burst_delayed);
                $finish;
            end
            if (axi_aw_size !== axi_aw_size_delayed) begin
                $error("Write Address Channel: Size changed during Ready negated. Current: %b, Delayed: %b", 
                       axi_aw_size, axi_aw_size_delayed);
                $finish;
            end
            if (axi_aw_id !== axi_aw_id_delayed) begin
                $error("Write Address Channel: ID changed during Ready negated. Current: %b, Delayed: %b", 
                       axi_aw_id, axi_aw_id_delayed);
                $finish;
            end
            if (axi_aw_len !== axi_aw_len_delayed) begin
                $error("Write Address Channel: Length changed during Ready negated. Current: %b, Delayed: %b", 
                       axi_aw_len, axi_aw_len_delayed);
                $finish;
            end
            if (axi_aw_valid !== axi_aw_valid_delayed) begin
                $error("Write Address Channel: Valid changed during Ready negated. Current: %b, Delayed: %b", 
                       axi_aw_valid, axi_aw_valid_delayed);
                $finish;
            end
        end
    end
end

// Readアドレスチャネルのペイロードホールド確認（リセット解除後に監視開始）
always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        // リセット中は監視しない
    end else begin
        if (!axi_ar_ready_delayed) begin
            // Readyがネゲートされている時にペイロードが変わっていないかチェック
            if (axi_ar_addr !== axi_ar_addr_delayed) begin
                $error("Read Address Channel: Address changed during Ready negated. Current: 0x%h, Delayed: 0x%h", 
                       axi_ar_addr, axi_ar_addr_delayed);
                $finish;
            end
            if (axi_ar_burst !== axi_ar_burst_delayed) begin
                $error("Read Address Channel: Burst changed during Ready negated. Current: %b, Delayed: %b", 
                       axi_ar_burst, axi_ar_burst_delayed);
                $finish;
            end
            if (axi_ar_size !== axi_ar_size_delayed) begin
                $error("Read Address Channel: Size changed during Ready negated. Current: %b, Delayed: %b", 
                       axi_ar_size, axi_ar_size_delayed);
                $finish;
            end
            if (axi_ar_id !== axi_ar_id_delayed) begin
                $error("Read Address Channel: ID changed during Ready negated. Current: %b, Delayed: %b", 
                       axi_ar_id, axi_ar_id_delayed);
                $finish;
            end
            if (axi_ar_len !== axi_ar_len_delayed) begin
                $error("Read Address Channel: Length changed during Ready negated. Current: %b, Delayed: %b", 
                       axi_ar_len, axi_ar_len_delayed);
                $finish;
            end
            if (axi_ar_valid !== axi_ar_valid_delayed) begin
                $error("Read Address Channel: Valid changed during Ready negated. Current: %b, Delayed: %b", 
                       axi_ar_valid, axi_ar_valid_delayed);
                $finish;
            end
        end
    end
end

// Writeデータチャネルのペイロードホールド確認（リセット解除後に監視開始）
always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        // リセット中は監視しない
    end else begin
        if (!axi_w_ready_delayed) begin
            // Readyがネゲートされている時にペイロードが変わっていないかチェック
            if (axi_w_data !== axi_w_data_delayed) begin
                $error("Write Data Channel: Data changed during Ready negated. Current: 0x%h, Delayed: 0x%h", 
                       axi_w_data, axi_w_data_delayed);
                $finish;
            end
            if (axi_w_strb !== axi_w_strb_delayed) begin
                $error("Write Data Channel: Strobe changed during Ready negated. Current: %b, Delayed: %b", 
                       axi_w_strb, axi_w_strb_delayed);
                $finish;
            end
            if (axi_w_last !== axi_w_last_delayed) begin
                $error("Write Data Channel: Last changed during Ready negated. Current: %b, Delayed: %b", 
                       axi_w_last, axi_w_last_delayed);
                $finish;
            end
            if (axi_w_valid !== axi_w_valid_delayed) begin
                $error("Write Data Channel: Valid changed during Ready negated. Current: %b, Delayed: %b", 
                       axi_w_valid, axi_w_valid_delayed);
                $finish;
            end
        end
    end
end

// Readデータチャネルのペイロードホールド確認（リセット解除後に監視開始）
always_ff @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        // リセット中は監視しない
    end else begin
        if (!axi_r_ready_delayed) begin
            // Readyがネゲートされている時にペイロードが変わっていないかチェック
            if (axi_r_data !== axi_r_data_delayed) begin
                $error("Read Data Channel: Data changed during Ready negated. Current: 0x%h, Delayed: 0x%h", 
                       axi_r_data, axi_r_data_delayed);
                $finish;
            end
            if (axi_r_resp !== axi_r_resp_delayed) begin
                $error("Read Data Channel: Response changed during Ready negated. Current: %b, Delayed: %b", 
                       axi_r_resp, axi_r_resp_delayed);
                $finish;
            end
            if (axi_r_last !== axi_r_last_delayed) begin
                $error("Read Data Channel: Last changed during Ready negated. Current: %b, Delayed: %b", 
                       axi_r_last, axi_r_last_delayed);
                $finish;
            end
            if (axi_r_valid !== axi_r_valid_delayed) begin
                $error("Read Data Channel: Valid changed during Ready negated. Current: %b, Delayed: %b", 
                       axi_r_valid, axi_r_valid_delayed);
                $finish;
            end
        end
    end
end

2.5 監視・ログ系

監視・ログ系では、テスト実行中の動作監視とログ出力を行います。

2.5.1 基本ログ機能

基本ログ機能では、フェーズ実行、転送、エラーの詳細な記録を行います。

// ログ制御用パラメータ
parameter LOG_ENABLE = 1'b1;           // ログ機能の有効/無効
parameter DEBUG_LOG_ENABLE = 1'b1;     // デバッグログの有効/無効
parameter LOG_FILE_PATH = "axi4_testbench.log";  // ログファイルパス

// ログ出力用ファイルハンドル
integer log_file_handle;

// ログ出力関数
function automatic void write_log(input string message);
    if (LOG_ENABLE) begin
        $fwrite(log_file_handle, "[%0t] %s\n", $time, message);
        $fflush(log_file_handle);
    end
endfunction

// デバッグログ出力関数
function automatic void write_debug_log(input string message);
    if (LOG_ENABLE && DEBUG_LOG_ENABLE) begin
        $fwrite(log_file_handle, "[%0t] [DEBUG] %s\n", $time, message);
        $fflush(log_file_handle);
    end
endfunction

// エラーログ出力関数
function automatic void write_error_log(input string message);
    if (LOG_ENABLE) begin
        $fwrite(log_file_handle, "[%0t] [ERROR] %s\n", $time, message);
        $fflush(log_file_handle);
        // コンソールにもエラーを表示
        $error("%s", message);
    end
endfunction

// ログファイルの初期化
initial begin
    if (LOG_ENABLE) begin
        log_file_handle = $fopen(LOG_FILE_PATH, "w");
        if (log_file_handle == 0) begin
            $error("Failed to open log file: %s", LOG_FILE_PATH);
        end else begin
            write_log("=== AXI4 Testbench Log Start ===");
            write_log("Test Parameters:");
            write_log("  - MEMORY_SIZE_BYTES: " + $sformatf("%0d", MEMORY_SIZE_BYTES));
            write_log("  - AXI_DATA_WIDTH: " + $sformatf("%0d", AXI_DATA_WIDTH));
            write_log("  - TOTAL_TEST_COUNT: " + $sformatf("%0d", TOTAL_TEST_COUNT));
            write_log("  - PHASE_TEST_COUNT: " + $sformatf("%0d", PHASE_TEST_COUNT));
        end
    end
end

// フェーズ実行ログ
always_ff @(posedge clk) begin
    if (LOG_ENABLE && !rst_n) begin
        // リセット解除時のログ
        write_log("Reset deasserted - Test execution started");
    end
end

// フェーズ開始ログ
always @(posedge clk) begin
    if (LOG_ENABLE && write_addr_phase_start) begin
        write_log($sformatf("Phase %0d: Write Address Channel started", current_phase));
    end
    if (LOG_ENABLE && read_addr_phase_start) begin
        write_log($sformatf("Phase %0d: Read Address Channel started", current_phase));
    end
    if (LOG_ENABLE && write_data_phase_start) begin
        write_log($sformatf("Phase %0d: Write Data Channel started", current_phase));
    end
    if (LOG_ENABLE && read_data_phase_start) begin
        write_log($sformatf("Phase %0d: Read Data Channel started", current_phase));
    end
end

// フェーズ完了ログ
always @(posedge clk) begin
    if (LOG_ENABLE && write_addr_phase_done) begin
        write_log($sformatf("Phase %0d: Write Address Channel completed", current_phase));
    end
    if (LOG_ENABLE && read_addr_phase_done) begin
        write_log($sformatf("Phase %0d: Read Address Channel completed", current_phase));
    end
    if (LOG_ENABLE && write_data_phase_done) begin
        write_log($sformatf("Phase %0d: Write Data Channel completed", current_phase));
    end
    if (LOG_ENABLE && read_data_phase_done) begin
        write_log($sformatf("Phase %0d: Read Data Channel completed", current_phase));
    end
end

// 転送ログ（Writeアドレスチャネル）
always @(posedge clk) begin
    if (LOG_ENABLE && axi_aw_valid && axi_aw_ready) begin
        write_debug_log($sformatf("Write Address Transfer: Addr=0x%h, Burst=%b, Size=%b, ID=%b, Len=%0d, Phase=%0d", 
                                 axi_aw_addr, axi_aw_burst, axi_aw_size, axi_aw_id, axi_aw_len, current_phase));
    end
end

// 転送ログ（Readアドレスチャネル）
always @(posedge clk) begin
    if (LOG_ENABLE && axi_ar_valid && axi_ar_ready) begin
        write_debug_log($sformatf("Read Address Transfer: Addr=0x%h, Burst=%b, Size=%b, ID=%b, Len=%0d, Phase=%0d", 
                                 axi_ar_addr, axi_ar_burst, axi_ar_size, axi_ar_id, axi_ar_len, current_phase));
    end
end

// 転送ログ（Writeデータチャネル）
always @(posedge clk) begin
    if (LOG_ENABLE && axi_w_valid && axi_w_ready) begin
        write_debug_log($sformatf("Write Data Transfer: Data=0x%h, Strobe=%b, Last=%b, Phase=%0d", 
                                 axi_w_data, axi_w_strb, axi_w_last, current_phase));
    end
end

// 転送ログ（Readデータチャネル）
always @(posedge clk) begin
    if (LOG_ENABLE && axi_r_valid && axi_r_ready) begin
        write_debug_log($sformatf("Read Data Transfer: Data=0x%h, Resp=%b, Last=%b, Phase=%0d", 
                                 axi_r_data, axi_r_resp, axi_r_last, current_phase));
    end
end

// ストールログ
always @(posedge clk) begin
    if (LOG_ENABLE && axi_aw_valid && !axi_aw_ready) begin
        write_debug_log($sformatf("Write Address Stall: Addr=0x%h, Phase=%0d", axi_aw_addr, current_phase));
    end
    if (LOG_ENABLE && axi_ar_valid && !axi_ar_ready) begin
        write_debug_log($sformatf("Read Address Stall: Addr=0x%h, Phase=%0d", axi_ar_addr, current_phase));
    end
    if (LOG_ENABLE && axi_w_valid && !axi_w_ready) begin
        write_debug_log($sformatf("Write Data Stall: Data=0x%h, Phase=%0d", axi_w_data, current_phase));
    end
    if (LOG_ENABLE && axi_r_valid && !axi_r_ready) begin
        write_debug_log($sformatf("Read Data Stall: Data=0x%h, Phase=%0d", axi_r_data, current_phase));
    end
end

// エラー・警告ログ
always @(posedge clk) begin
    // プロトコル違反のログは既存の$error文で出力される
    // ここでは追加のエラー情報をログに記録
end

// テスト完了時の結果まとめ出力
initial begin
    // テスト完了を待機
    wait(generate_stimulus_expected_done);
    
    // 結果まとめをテキストで表示（ファイルには出力しない）
    $display("\n=== AXI4 Testbench Results Summary ===");
    $display("Test Configuration:");
    $display("  - Memory Size: %0d bytes (%0d MB)", MEMORY_SIZE_BYTES, MEMORY_SIZE_BYTES/1024/1024);
    $display("  - Data Width: %0d bits", AXI_DATA_WIDTH);
    $display("  - Total Test Count: %0d", TOTAL_TEST_COUNT);
    $display("  - Phase Test Count: %0d", PHASE_TEST_COUNT);
    $display("  - Number of Phases: %0d", (TOTAL_TEST_COUNT / PHASE_TEST_COUNT));
    
    // ログファイルに結果まとめを記録
    if (LOG_ENABLE) begin
        write_log("=== Test Results Summary ===");
        write_log($sformatf("Total Test Count: %0d", TOTAL_TEST_COUNT));
        write_log($sformatf("Number of Phases: %0d", (TOTAL_TEST_COUNT / PHASE_TEST_COUNT)));
        write_log("Test execution completed successfully");
        write_log("=== AXI4 Testbench Log End ===");
        $fclose(log_file_handle);
    end
end

2.5.2 ログ機能の特徴

ファイル出力制御: LOG_ENABLEパラメータでログ機能の有効/無効を制御
デバッグログ制御: DEBUG_LOG_ENABLEパラメータでデバッグログの有効/無効を制御
時間スタンプ: 全てのログにシミュレーション時間を記録
リアルタイム出力: $fflushでログファイルへの即座な出力を保証
結果まとめ: テスト完了時の結果はコンソールに表示、詳細ログはファイルに記録

2.6 重み付き乱数発生系

テストベンチにおいて、特定の値の出現頻度を制御したい場合があります。例えば、READY信号をネゲートする頻度を制御して、ストールの発生パターンの調整です。

重み付き乱数の基本概念

重み付き乱数は、各値に重み（出現確率）を設定し、その重みに基づいて乱数を発生させる手法です。これにより、テストシナリオに適した確率分布を持つ乱数を生成できます。

統一された重み付き乱数システム

基本パラメータ設定で定義された統一された関数を使用して、全ての配列で一貫した重み付き乱数生成が可能です。

統一された重み付き乱数生成関数の定義

// 統一された重み付き乱数生成関数
function automatic int generate_weighted_random_index(
    input int weights[],
    input int total_weight
);
    int random_val;
    int cumulative_weight = 0;
    
    // 0から総重み-1の範囲で乱数生成
    random_val = $urandom_range(0, total_weight - 1);
    
    // 重みに基づくインデックスの選択
    for (int i = 0; i < weights.size(); i++) begin
        cumulative_weight += weights[i];
        if (random_val < cumulative_weight) begin
            return i;
        end
    end
    
    // デフォルト値
    return 0;
endfunction

// 統一された重み配列抽出関数
function automatic int[] extract_weights_generic(
    input int weight_field[],
    input int array_size
);
    int weights[];
    weights = new[array_size];
    
    for (int i = 0; i < array_size; i++) begin
        weights[i] = weight_field[i];
    end
    
    return weights;
endfunction

// 統一された総重み計算関数
function automatic int calculate_total_weight_generic(
    input int weights[]
);
    int total = 0;
    foreach (weights[i]) begin
        total += weights[i];
    end
    return total;
endfunction

共通関数の使用方法

// 1. 重み配列の抽出
int[] weights = extract_weights_generic(target_array, target_array.size());

// 2. 総重みの計算
int total_weight = calculate_total_weight_generic(weights);

// 3. 重み付き乱数でインデックスを選択
int selected_index = generate_weighted_random_index(weights, total_weight);

// 4. 選択されたインデックスから値を取得
// （配列の型に応じて適切なフィールドにアクセス）

具体例1: r_ready_negate_weightsでの使用

// r_ready_negate_weightsでの重み付き乱数生成
int[] r_ready_weights = extract_weights_generic(r_ready_negate_weights, r_ready_negate_weights.size());
int r_ready_total = calculate_total_weight_generic(r_ready_weights);
int r_ready_index = generate_weighted_random_index(r_ready_weights, r_ready_total);

// 選択された設定から値を取得
int r_ready_cycles = $urandom_range(
    r_ready_negate_weights[r_ready_index].cyc_cnt_start,
    r_ready_negate_weights[r_ready_index].cyc_cnt_end
);

$display("r_ready_negate: Index=%0d, Cycles=%0d", r_ready_index, r_ready_cycles);

具体例2: burst_config_weightsでの使用

// burst_config_weightsでの重み付き乱数生成
int[] burst_weights = extract_weights_generic(burst_config_weights, burst_config_weights.size());
int burst_total = calculate_total_weight_generic(burst_weights);
int burst_index = generate_weighted_random_index(burst_weights, burst_total);

// 選択された設定から値を取得
burst_config_t selected_burst = burst_config_weights[burst_index];
int selected_length = $urandom_range(selected_burst.length_min, selected_burst.length_max);
string selected_type = selected_burst.burst_type;

$display("Burst Config: Index=%0d, LENGTH=%0d-%0d, TYPE=%s, Generated LENGTH=%0d", 
         burst_index, selected_burst.length_min, selected_burst.length_max, 
         selected_type, selected_length);

具体例3: 統合使用例

// テストシーケンスでの統合使用
task generate_test_sequence;
    // 1. バースト設定の生成
    int[] burst_weights = extract_weights_generic(burst_config_weights, burst_config_weights.size());
    int burst_total = calculate_total_weight_generic(burst_weights);
    int burst_index = generate_weighted_random_index(burst_weights, burst_total);
    burst_config_t selected_burst = burst_config_weights[burst_index];
    
    // 2. r_readyネゲート設定の生成
    int[] r_ready_weights = extract_weights_generic(r_ready_negate_weights, r_ready_negate_weights.size());
    int r_ready_total = calculate_total_weight_generic(r_ready_weights);
    int r_ready_index = generate_weighted_random_index(r_ready_weights, r_ready_total);
    int r_ready_cycles = $urandom_range(
        r_ready_negate_weights[r_ready_index].cyc_cnt_start,
        r_ready_negate_weights[r_ready_index].cyc_cnt_end
    );
    
    // 3. 結果の表示
    $display("=== Test Sequence Generated ===");
    $display("Burst: LENGTH=%0d-%0d, TYPE=%s", 
             selected_burst.length_min, selected_burst.length_max, selected_burst.burst_type);
    $display("r_ready negate: %0d cycles", r_ready_cycles);
    
    // 4. 実際のテスト実行
    execute_test_sequence(selected_burst, r_ready_cycles);
endtask

重み付き乱数の利点

テストカバレッジの向上: 特定のシナリオの発生確率を制御
デバッグ効率の向上: 問題が発生しやすい条件を重点的にテスト
設定の柔軟性: パラメータファイルで簡単に調整可能
再利用性: 共通関数により様々な配列で使用可能
一貫性: 全ての配列で同じパターンで乱数生成

この統一された重み付き乱数システムにより、テストベンチの動作を詳細に制御し、効率的なテストシナリオの実行が可能になります。

3. テストベンチのコード

テストベンチのコード: axi_simple_dual_port_ram_tb.v

ライセンス

Licensed under the Apache License, Version 2.0 - see LICENSE file for details.