12. Generate блоки Verilog HDL

module_or_generate_item ::=
    { attribute_instance } module_or_generate_item_declaration
    | { attribute_instance } local_parameter_declaration ;
    | { attribute_instance } parameter_override
    | { attribute_instance } continuous_assign
    | { attribute_instance } gate_instantiation
    | { attribute_instance } udp_instantiation
    | { attribute_instance } module_instantiation
    | { attribute_instance } initial_construct
    | { attribute_instance } always_construct
    | { attribute_instance } loop_generate_construct
    | { attribute_instance } conditional_generate_construct
generate_region ::=
    generate { module_or_generate_item } endgenerate
genvar_declaration ::=
    genvar list_of_genvar_identifiers ;
list_of_genvar_identifiers ::=
    genvar_identifier { , genvar_identifier }
loop_generate_construct ::=
    for ( genvar_initialization ; genvar_expression ; genvar_iteration )
    generate_block
genvar_initialization ::=
    genvar_identifier = constant_expression
genvar_expression ::=
    genvar_primary
    | unary_operator { attribute_instance } genvar_primary
    | genvar_expression binary_operator { attribute_instance } genvar_expression
    | genvar_expression ? { attribute_instance } genvar_expression : genvar_expression
genvar_iteration ::=
    genvar_identifier = genvar_expression
genvar_primary ::=
    constant_primary
    | genvar_identifier
conditional_generate_construct ::=
    if_generate_construct
    | case_generate_construct
if_generate_construct ::=
    if ( constant_expression ) generate_block_or_null
    [ else generate_block_or_null ]
case_generate_construct ::=
    case ( constant_expression )
    case_generate_item { case_generate_item } endcase
case_generate_item ::=
    constant_expression { , constant_expression } : generate_block_or_null
    | default [ : ] generate_block_or_null
generate_block ::=
    module_or_generate_item
    | begin [ : generate_block_identifier ] { module_or_generate_item } end
generate_block_or_null ::=
    generate_block | ;

module mod_a;
    genvar i;
    // Ключевые слова "generate", "endgenerate" необязательны
    for (i=0; i<5; i=i+1) begin:a
        for (i=0; i<5; i=i+1) begin:b
            ... // ошибка -- использование "i" d в качестве индекса цикла for
            ... // два вложенных порождающих цикла
        end
    end
endmodule
------
module mod_b;
    genvar i;
    reg a;
    for (i=1; i<0; i=i+1) begin: a
    ... // ошибка -- "a" конфликтует с именем reg "a"
    end
endmodule
------
module mod_c;
    genvar i;
    for (i=1; i<5; i=i+1) begin: a
        ...
    end
    for (i=10; i<15; i=i+1) begin: a
        ... // ошибка -- "a" конфилктует с предыдущем
        ... // циклом даже если индексы уникальны
    end
endmodule

module gray2bin1 (bin, gray);
    parameter SIZE = 8; // этот модуль параметризированный
    output [SIZE-1:0] bin;
    input [SIZE-1:0] gray;
    genvar i;
    generate
        for (i=0; i<SIZE; i=i+1) begin:bit
            assign bin[i] = ^gray[SIZE-1:i];
                        // i ссылается на неявно объявленный localparam чьё
                        // значение в каждом экземпляре блока generate является
                        // значение genvar на момент его разработки.
        end
    endgenerate
endmodule

module addergen1 (co, sum, a, b, ci);
    parameter SIZE = 4;
    output [SIZE-1:0] sum;
    output co;
    input [SIZE-1:0] a, b;
    input ci;
    wire [SIZE :0] c;
    wire [SIZE-1:0] t [1:3];
    genvar i;
    assign c[0] = ci;
    // Иерархические имена экземпляров вентилей:
    // xor вентили: bit[0].g1 bit[1].g1 bit[2].g1 bit[3].g1
    // bit[0].g2 bit[1].g2 bit[2].g2 bit[3].g2
    // and вентили: bit[0].g3 bit[1].g3 bit[2].g3 bit[3].g3
    // bit[0].g4 bit[1].g4 bit[2].g4 bit[3].g4
    // or вентили: bit[0].g5 bit[1].g5 bit[2].g5 bit[3].g5
    // Сгенерированные экземпляры связаны с
    // многомерные сети t[1][3:0] t[2][3:0] t[3][3:0]
    // (Всего 12 сетей)
    for(i=0; i<SIZE; i=i+1) begin:bit
        xor g1 ( t[1][i], a[i], b[i]);
        xor g2 ( sum[i], t[1][i], c[i]);
        and g3 ( t[2][i], a[i], b[i]);
        and g4 ( t[3][i], t[1][i], c[i]);
        or g5 ( c[i+1], t[2][i], t[3][i]);
    end
    assign co = c[SIZE];
endmodule

module addergen1 (co, sum, a, b, ci);
    parameter SIZE = 4;
    output [SIZE-1:0] sum;
    output co;
    input [SIZE-1:0] a, b;
    input ci;
    wire [SIZE :0] c;
    genvar i;
    assign c[0] = ci;
    // Иерархические имена экземпляров вентилей:
    // xor вентили: bit[0].g1 bit[1].g1 bit[2].g1 bit[3].g1
    // bit[0].g2 bit[1].g2 bit[2].g2 bit[3].g2
    // and вентили: bit[0].g3 bit[1].g3 bit[2].g3 bit[3].g3
    // bit[0].g4 bit[1].g4 bit[2].g4 bit[3].g4
    // or вентили: bit[0].g5 bit[1].g5 bit[2].g5 bit[3].g5
    // Экземпляры вентилей соединенные сетями с именами:
    // bit[0].t1 bit[1].t1 bit[2].t1 bit[3].t1
    // bit[0].t2 bit[1].t2 bit[2].t2 bit[3].t2
    // bit[0].t3 bit[1].t3 bit[2].t3 bit[3].t3
    for(i=0; i<SIZE; i=i+1) begin:bit
        wire t1, t2, t3;
        xor g1 ( t1, a[i], b[i]);
        xor g2 ( sum[i], t1, c[i]);
        and g3 ( t2, a[i], b[i]);
        and g4 ( t3, t1, c[i]);
        or g5 ( c[i+1], t2, t3);
    end
    assign co = c[SIZE];
endmodule

parameter SIZE = 2;
genvar i, j, k, m;
generate
    for (i=0; i<SIZE; i=i+1) begin:B1 // область B1[i]
        M1 N1(); // экземпляры B1[i].N1
        for (j=0; j<SIZE; j=j+1) begin:B2 // область B1[i].B2[j]
        M2 N2(); // instantiates B1[i].B2[j].N2
            for (k=0; k<SIZE; k=k+1) begin:B3 // область B1[i].B2[j].B3[k]
                M3 N3(); // экземпляры B1[i].B2[j].B3[k].N3
            end
        end
        if (i>0) begin:B4 // область B1[i].B4
            for (m=0; m<SIZE; m=m+1) begin:B5 // область B1[i].B4.B5[m]
                M4 N4(); // экземпляры B1[i].B4.B5[m].N4
            end
        end
    end
endgenerate
    // Некоторые примеры иерархических имен для экземпляров модуля:
    // B1[0].N1 B1[1].N1
    // B1[0].B2[0].N2 B1[0].B2[1].N2
    // B1[0].B2[0].B3[0].N3 B1[0].B2[0].B3[1].N3
    // B1[0].B2[1].B3[0].N3
    // B1[1].B4.B5[0].N4 B1[1].B4.B5[1].N4

module test;
    parameter p = 0, q = 0;
    wire a, b, c;
    //---------------------------------------------------------
    // Код для генерации экземпляра u1.g1 или отсутствия экземпляра.
    // Экземпляр u1.g1 одного из следующих вентилей:
    // (and, or, xor, xnor) генерируются если
    // {p,q} == {1,0}, {1,2}, {2,0}, {2,1}, {2,2}, {2, default}
    //---------------------------------------------------------
    if (p == 1)
        if (q == 0)
        begin : u1 // Если p==1 и q==0, то объявляет экземпляр
            and g1(a, b, c); // AND с иерархическим именем test.u1.g1
        end
    else if (q == 2)
        begin : u1 // Если p==1 и q==2, то объявляет экземпляр
            or g1(a, b, c); // OR с иерархическим именем test.u1.g1
        end
        // "else" добавлено в конец объявления "if (q == 2)".
        else ; // Если p==1 и q!=0 или 2, то не объявляет экземпляр
    else if (p == 2)
        case (q)
        0, 1, 2:
            begin : u1 // Если p==2 т q==0,1, или 2, то объявляет экземпляр
                xor g1(a, b, c);// XOR с иерархическим именем test.u1.g1
            end
        default:
            begin : u1 // Если p==2 и q!=0,1, или 2, то объявляет экземпляр
                xnor g1(a, b, c);// XNOR с иерархическим именем test.u1.g1
            end
    endcase
endmodule

module multiplier(a,b,product);
    parameter a_width = 8, b_width = 8;
    localparam product_width = a_width+b_width;
                // не может быть изменен непосредственно с помощью объявления defparam
                // или объявления экземпляра модуля #
    input [a_width-1:0] a;
    input [b_width-1:0] b;
    output [product_width-1:0] product;

    generate
        if((a_width < 8) || (b_width < 8)) begin: mult
        CLA_multiplier #(a_width,b_width) u1(a, b, product);
        // объявление экземпляра множителя CLA
        end
        else begin: mult
        WALLACE_multiplier #(a_width,b_width) u1(a, b, product);
        // объявление экземпляра множителя дерева Уоллеса
        end
    endgenerate
    // Иерархическое имя экземпляра mult.u1

endmodule

generate
    case (WIDTH)
        1: begin: adder     // реализация 1-битного сумматора
            adder_1bit x1(co, sum, a, b, ci);
        end
        2: begin: adder     // реализация 2-битного сумматора
            adder_2bit x1(co, sum, a, b, ci);
        end
        default:
        begin: adder        // другие - неопреленные ширины сумматоры с переносом
            adder_cla #(WIDTH) x1(co, sum, a, b, ci);
        end
    endcase
    // Иерархическое имя экземпляра - adder.x1
endgenerate

module dimm(addr, ba, rasx, casx, csx, wex, cke, clk, dqm, data, dev_id);

    parameter [31:0] MEM_WIDTH = 16, MEM_SIZE = 8; // в мегабайтах

    input [10:0] addr;
    input ba, rasx, casx, csx, wex, cke, clk;
    input [ 7:0] dqm;
    inout [63:0] data;
    input [ 4:0] dev_id;

    genvar i;

    case ({MEM_SIZE, MEM_WIDTH})
    {32'd8, 32'd16}: // 8Meg x 16 бит в ширину
    begin: memory
        for (i=0; i<4; i=i+1) begin:word
            sms_08b216t0 p(.clk(clk), .csb(csx), .cke(cke),.ba(ba),
                        .addr(addr), .rasb(rasx), .casb(casx),
                        .web(wex), .udqm(dqm[2*i+1]), .ldqm(dqm[2*i]),
                        .dqi(data[15+16*i:16*i]), .dev_id(dev_id));
            // Иерархические имена экземпляров - memory.word[3].p,
            // memory.word[2].p, memory.word[1].p, memory.word[0].p,
            // и задача memory.read_mem
        end
        task read_mem;
            input [31:0] address;
            output [63:0] data;
            begin                   // вызов read_mem в sms модуле
                word[3].p.read_mem(address, data[63:48]);
                word[2].p.read_mem(address, data[47:32]);
                word[1].p.read_mem(address, data[31:16]);
                word[0].p.read_mem(address, data[15: 0]);
            end
        endtask
    end
    {32'd16, 32'd8}: // 16Meg x 8 бит в ширину
    begin: memory
        for (i=0; i<8; i=i+1) begin:byte
            sms_16b208t0 p(.clk(clk), .csb(csx), .cke(cke),.ba(ba),
                        .addr(addr), .rasb(rasx), .casb(casx),
                        .web(wex), .dqm(dqm[i]),
                        .dqi(data[7+8*i:8*i]), .dev_id(dev_id));
            // Иерархические имена экземпляров - memory.byte[7].p,
            // memory.byte[6].p, ... , memory.byte[1].p, memory.byte[0].p,
            // и задача memory.read_mem
        end
        task read_mem;
            input [31:0] address;
            output [63:0] data;
            begin // call read_mem in sms module
                byte[7].p.read_mem(address, data[63:56]);
                byte[6].p.read_mem(address, data[55:48]);
                byte[5].p.read_mem(address, data[47:40]);
                byte[4].p.read_mem(address, data[39:32]);
                byte[3].p.read_mem(address, data[31:24]);
                byte[2].p.read_mem(address, data[23:16]);
                byte[1].p.read_mem(address, data[15: 8]);
                byte[0].p.read_mem(address, data[ 7: 0]);
            end
        endtask
    end
    // Другие случаи памяти ...
    endcase
endmodule

module top;

    parameter genblk2 = 0;
    genvar i;

    // Следующий блок генерации неявно назван genblk1

    if (genblk2) reg a; // top.genblk1.a
    else reg b; // top.genblk1.b

    // Следующий блок генерации имеет неявное имя genblk02
    // поскольку genblk2 уже является объявленным идентификатором

    if (genblk2) reg a; // top.genblk02.a
    else reg b; // top.genblk02.b

    // Следующий блок generate был бы назван genblk3
    // но имеет явное название g1

    for (i = 0; i < 1; i = i + 1) begin : g1 // Имя блока
        // Следующий блок генерации неявно назван genblk1
        // как первая вложенная область видимости внутри g1
        if (1) reg a; // top.g1[0].genblk1.a
    end

    // Следующий блок генерации неявно назван genblk4, поскольку
    // он принадлежит четвертой конструкции generate в области видимости "top".
    // Предыдущий блок генерации был бы
    // назван genblk3, если он не был явно назван g1

    for (i = 0; i < 1; i = i + 1)
        // Следующий блок генерации неявно назван genblk1
        // как первый вложенный блок generate в genblk4
        if (1) reg a; // top.genblk4[0].genblk1.a

    // Следующий блок генерации имеет неявное имя genblk5
    if (1) reg a; // top.genblk5.a

endmodule