Verilog Bitwise ve Reduction Operatörleri

Aynı Sembol İçin İki Rol

&, |, ^ ve bunların ters kardeşleri iki farklı şekilde karşına çıkar:

• İkili form (iki operand): a & b - eşit genişlikteki vektörler arasında bitwise işlem.
• Tekli form (tek operand): &a - a'nın tüm bitlerini tek bite indirgeyen reduction.

Derleyici operand sayısını sayarak ikisini ayırır. Adlandırma geleneği ikili form için "bitwise operatörleri", tekli form için "reduction operatörleri" şeklindedir.

Bitwise: Bir Seferde Bir Bit

module bitwise;
    wire [7:0] a = 8'b1100_1010;
    wire [7:0] b = 8'b0101_1100;

    initial begin
        $display("a    = %b", a);
        $display("b    = %b", b);
        $display("a & b = %b", a & b);   // bitwise AND
        $display("a | b = %b", a | b);   // bitwise OR
        $display("a ^ b = %b", a ^ b);   // bitwise XOR
        $display("~a    = %b", ~a);      // bitwise NOT (tek operand)
        $display("a ~^ b = %b", a ~^ b); // bitwise XNOR
        $finish;
    end
endmodule

Tam set:

Operatör	Ad	N pozisyonundaki çıkış biti
a & b	AND	a[N] AND b[N]
a | b	OR	a[N] OR b[N]
a ^ b	XOR	a[N] XOR b[N]
a ~& b	NAND	NOT (a[N] AND b[N])
a ~| b	NOR	NOT (a[N] OR b[N])
a ~^ b	XNOR	NOT (a[N] XOR b[N])
~a	NOT	NOT a[N]

~&, ~|, ~^ operatörlerinin önce tilde, sonra operatör olarak yazıldığına dikkat et. Tek bir token'dır; aralarında boşluk yoktur.

İki operand farklı genişlikte olduğunda, daha dar olan eşleştirmek için solda sıfır ile genişletilir. Sign-extension istiyorsan, $signed() ile operandları açıkça signed yap.

Reduction: Birden Çok Bit'ten Bir Bit'e

Aynı operatörlerin tekli formları bir vektörü tek bir bite indirir:

module reduction;
    wire [7:0] data1 = 8'b1111_1111;
    wire [7:0] data2 = 8'b0000_0001;
    wire [7:0] data3 = 8'b0101_0101;
    wire [7:0] data4 = 8'b0000_0000;

    initial begin
        $display("data = %b   &data  |data  ^data  $isunknown", data1);
        $display("       %b      %b     %b     %b", data1, &data1, |data1, ^data1);
        $display("       %b      %b     %b     %b", data2, &data2, |data2, ^data2);
        $display("       %b      %b     %b     %b", data3, &data3, |data3, ^data3);
        $display("       %b      %b     %b     %b", data4, &data4, |data4, ^data4);
        $finish;
    end
endmodule

Her birinin anlamı:

• &data, data'nın tüm bitleri 1 ise 1, aksi halde 0 döndürür. "Tamamen birler mi?" kontrolleri için kullanışlı.
• |data, data'nın herhangi bir biti 1 ise 1, aksi halde 0 döndürür. "Sıfır değil mi?" kontrolleri için kullanışlı.
• ^data, parity döndürür - tüm bitlerin XOR'u. 1'lerin sayısı tek ise 1, çift ise 0.
• ~&data, ~|data, ~^data yukarıdakilerin tersleridir.

Gerçek kodda bunları her yerde göreceksin:

wire empty       = ~|fifo_count;       // count sıfırsa empty
wire all_ones    = &mask;              // tüm bitler set
wire parity_bit  = ^data;              // bir byte'ın parity'si
wire any_request = |request_vector;    // herhangi bir istek var mı?

Reduction formları özlüdür ve bariz gate ağaçlarına sentezlenir: & çok girişli bir AND gate'e, | çok girişli bir OR'a, ^ ise bir XOR ağacına (ki bu donanımda parity üretecidir) indirgenir.

Yaygın Kalıplar

Bitleri Set ve Clear Etme

wire [7:0] data;
wire [7:0] mask = 8'b0000_1000;

wire [7:0] set     = data | mask;     // bit 3'ü 1 yapar
wire [7:0] cleared = data & ~mask;    // bit 3'ü 0 yapar
wire [7:0] toggled = data ^ mask;     // bit 3'ü flip eder
wire [7:0] tested  = data & mask;     // bit 3 0 ise sıfır, aksi halde sıfır değil

C'de kullanacağın bit manipülasyon deyimlerinin aynısı. Tek-gate'lik işlemlere sentezlenirler.

Bir Değerin Tamamen Birlere Eşit Olup Olmadığını Kontrol Etme

wire is_max = &counter;       // counter'ın her biti 1 ise 1

Tek bir gate'lik bir reduction AND, vs counter == 8'hFF yazmak (bu da çalışır; sentezleyiciler genellikle aynı donanımı üretir).

Parity Biti Üretme

module parity_demo;
    reg  [7:0] data;
    wire       parity = ^data;          // even parity biti
    wire       odd_parity = ~^data;     // odd parity biti

    initial begin
        for (integer i = 0; i < 8; i = i + 1) begin
            data = 8'd1 << i;
            #1 $display("data=%b parity=%b odd=%b", data, parity, odd_parity);
        end
        $finish;
    end
endmodule

Aktif Sinyalleri Tespit Etme

wire any_pending = |request_vector;

request_vector genişse (örneğin 64 istek), reduction OR onu bir priority encoder'a veya arbiter'a besleyebileceğin tek bir sinyale indirir.

Shift Operatörleri

Bit düzeyi operatörlerindeyken, shift'ler de:

• a << N, a'yı N bit pozisyon sola kaydırır, sağı sıfırlarla doldurur.
• a >> N, a'yı N bit pozisyon sağa kaydırır, solu sıfırlarla doldurur.
• a <<< N aritmetik sol shift (unsigned için << ile aynı).
• a >>> N aritmetik sağ shift - a signed olduğunda sign biti ile doldurur.

module shifts;
    initial begin
        $display("8'b0011_1100 << 2 = %b", 8'b0011_1100 << 2);
        $display("8'b0011_1100 >> 2 = %b", 8'b0011_1100 >> 2);

        // Signed değerde aritmetik sağ shift işareti korur:
        $display("8'sb1100_0000 >>> 2 = %b", $signed(8'sb1100_0000) >>> 2);
        $finish;
    end
endmodule

Sabit bir kuvvet ile shift donanımda bedavadır (sadece yeniden kablolama). Çalışma zamanı değişkeni ile shift barrel shifter üretir, bu daha büyüktür ama yine de ucuzdur.

Sırada Ne Var

Tek bir değer döndüren her operatörü gördün. Bir sonraki doc - Concatenation and Replication - parçalardan daha geniş vektörler kuran {} ve {N{...}} sözdizimini kapsar; farklı genişlikteki modüller arasında arayüz oluştururken sürekli kullanacaksın.