Verilog Operatörleri: Aritmetik, Karşılaştırma, Mantıksal ve Koşullu

Verilog'da "Operatör" Ne Demek

Operatörler sinyal taşıyan ifadeleri alır ve yeni sinyal taşıyan ifadeler üretir. a + b donanımdır - sentezleyici onu bir adder'a dönüştürür. a == b donanımdır - bir karşılaştırıcı kurar. Bunların hiçbiri "çalışan kod" değildir; hepsi "operatörün tanımladığı devreler"dir.

Tam operatör menüsü ezberleyecek kadar küçüktür. Bu doc aritmetik, karşılaştırma, mantıksal ve koşullu operatörleri kapsar. Bitwise and Reduction, doğrudan yazılım karşılığı olmayan bit düzeyi operatörlerini kapsar.

Aritmetik: + - * / %

module arithmetic;
    initial begin
        $display("17 +  5 = %0d", 17 + 5);
        $display("17 -  5 = %0d", 17 - 5);
        $display("17 *  5 = %0d", 17 * 5);
        $display("17 /  5 = %0d", 17 / 5);   // integer bölme: 3
        $display("17 %% 5 = %0d", 17 % 5);   // modulo: 2
        $display("-3 *  4 = %0d", -3 * 4);   // signed ile çalışır
        $finish;
    end
endmodule

Bilmeniz gereken üç şey:

1. Bölme integer bölmedir. 7/2, 3.5 değil 3'tür. Verilog'un bir float tipi yoktur (eh, real var ama o yalnızca simülasyon).
2. Bölme ve modulo donanımda pahalıdır. Bir /4 iyidir (sentezleyici onu bir sağ shift'e dönüştürür), ama çalışma zamanı değişken n için bir /n neredeyse hiç istemediğin çok döngülü bir divider kurar.
3. Taşma sarar. N bit aşan iki N bitlik unsigned değerin toplanması N bite truncate olur. Carry'yi yakalamak istiyorsan, sonucu bir bit daha geniş tanımla:

wire [7:0] a, b;
wire [8:0] sum = a + b;   // 9 bitlik sum carry out'u yakalar

Karşılaştırma: == != < > <= >=

module comparison;
    initial begin
        $display("5 ==  5 = %b", 5 == 5);
        $display("5 !=  3 = %b", 5 != 3);
        $display("5 <   3 = %b", 5 < 3);
        $display("5 >=  5 = %b", 5 >= 5);

        // Dikkat: x ile karşılaştırma 0 değil x üretir
        $display("1'bx == 1'b0 = %b", 1'bx == 1'b0);   // x
        $display("1'bx === 1'b0 = %b", 1'bx === 1'b0); // 0

        $finish;
    end
endmodule

Altı karşılaştırma operatörü de tek bitlik bir sonuç döndürür: doğruysa 1, yanlışsa 0, herhangi bir operand'da x veya z bit varsa x. x/z durumunu işlemek için, X and Z Values bölümünde kapsanan === ve !== (case-equality operatörleri) için uzan.

Burada <= karşılaştırma operatörüdür (küçük eşit). Aynı karakterler bir prosedürel blokta non-blocking atama da demektir (q <= d). Bağlam bunları ayırır: bir ifade içinde karşılaştırmadır; atanan bir değerin solunda atamadır. Örtüşme kafa karıştırıcıdır ama parser için belirsizdir.

Mantıksal: && || !

Mantıksal operatörler operandlarını boolean olarak ele alır (sıfır olmayan her şey doğrudur, sıfır yanlıştır) ve tek bitlik bir sonuç üretir:

module logical;
    initial begin
        $display("(5 > 3) && (2 < 4) = %b", (5 > 3) && (2 < 4));
        $display("(5 > 3) || (2 > 4) = %b", (5 > 3) || (2 > 4));
        $display("!(5 > 3)           = %b", !(5 > 3));

        // Çok bitli değerlerde mantıksal: sıfır olmayan her şey "doğru"
        $display("4'b1100 && 4'b0011 = %b", 4'b1100 && 4'b0011);   // 1
        $display("4'b1100 || 4'b0000 = %b", 4'b1100 || 4'b0000);   // 1
        $finish;
    end
endmodule

İçselleştirilecek kritik ayrım: mantıksal &&, bitwise & değildir.

4'b1100 && 4'b0011   // 1 (ikisi de sıfır olmayan, mantıksal AND doğru)
4'b1100 &  4'b0011   // 4'b0000 (ikisinde de hiçbir bit pozisyonu 1 değil)

|| vs | için aynı. if koşullarında ve ?: yüklemlerinde mantıksal kullan; her bit pozisyonunun bağımsız olarak AND/OR olmasını istediğinde bitwise kullan.

&& ve ||, C anlamında short-circuit'tir: sağ taraf, sonuç sol tarafa göre zaten belirlenmişse değerlendirilmez. Bu, pointer'ları veya fonksiyon çağrılarını kontrol eden testbench'ler için önemlidir; her şeyin zaten paralel olduğu sentezlenebilir RTL için nadiren önemlidir.

Koşullu Operatör: ?:

Ternary, mux ve koşullu ifadeler kurmak için en iyi arkadaşındır:

module muxes;
    wire [3:0] a = 4'hA;
    wire [3:0] b = 4'hB;
    wire sel;

    // 2-to-1 mux:
    wire [3:0] out = sel ? a : b;

    // 4-to-1 mux ?: zinciri olarak
    reg [1:0] sel4;
    wire [3:0] in0, in1, in2, in3;
    wire [3:0] out4 = (sel4 == 2'd0) ? in0
                    : (sel4 == 2'd1) ? in1
                    : (sel4 == 2'd2) ? in2
                    : in3;

    initial begin
        $display("a=%h b=%h out=%h",  a, b, out);
        $finish;
    end
endmodule

cond ? a : b kalıbı donanımda 1 bitlik-seçimli 2-to-1 bir multiplexer'dır. Bunları zincirlemek 3 ve 4 yollu seçimler için iyidir, ama ondan sonra bir case ifadesi ((Case Statement bölümünde kapsanır) dramatik olarak daha okunaklıdır.

?: operatörü ayrıca yalnızca bazen override ettiğin bir register'a varsayılan bir değer vermenin standart yoludur:

next_value = update ? new_data : next_value;

Genişlik Kuralları: Başlangıç Tuzağı

Aritmetik operatörler için Verilog'un genişlik kuralları kötü şöhretli derecede sürprizlidir. Kısa versiyon:

• Sonucun genişliği girişlerin genişliklerinin maksimumudur.
• Sonuç daha geniş bir şeye atanırsa, sıfır ile genişletilir (signed ise sign-extended).
• Ara hesaplamaların genişliği de sonuç genişliğidir, bu da taşmanın ara hesaplamada gerçekleştiği anlamına gelir.

module width_trap;
    reg [7:0]  a, b;
    reg [15:0] product;

    initial begin
        a = 8'd200;
        b = 8'd200;

        // a * b "40000 olmalı" (16 bite sığar)
        // ama çarpma 8 bitte olur, taşar, sonra atanır
        product = a * b;
        $display("8-bit *: product = %0d (40000 bekleniyor)", product);

        // Düzeltme: çarpmadan önce bir operandı daha geniş yap
        product = {8'b0, a} * b;
        $display("genişletilmiş: product = %0d", product);

        $finish;
    end
endmodule

İlk çarpma taşar çünkü operand genişlikleri her ikisi de 8 bittir, bu yüzden sonuç genişliği 8 bittir ve 40000 sığmaz. İkincisi çalışır çünkü çarpmadan önce a'yı açıkça genişlettik.

Düzeltme satır teknikleri:

• Sıfır ile genişletmek için concatenation operatörü {8'b0, a} kullan.
• Yorumlamayı etkilemek için $unsigned(a) veya $signed(a) kullan.
• Şüphe duyduğunda ara ifadeleri daha geniş genişliklere cast et.

Operatör Önceliği

Tabloyu ezberlemeyeceksin, ama birkaç kurala dayanacaksın:

• *, /, %, +, -'den daha sıkı bağlar.
• Karşılaştırma, mantıksal'dan (&&, ||) daha sıkı bağlar.
• Koşullu operatör ?: çok düşük önceliğe sahiptir - genellikle daha büyük ifadelerde dallarının etrafında parens gerekir.
• Şüphe ettiğinde, parantezle. Simülatör karakter başına ücret almıyor.

out = (mode == 2'd0) ? a + b : a - b;   // parens ile daha net

Sırada Ne Var

Yazılım kuzeni gibi görünen her operatörü kapsadın. Bir sonraki doc - Bitwise and Reduction - doğrudan yazılım karşılığı olmayan operatörleri ele alır: bit başına bitwise AND/OR/XOR, artı bütün bir vektörü tek bir bite indiren reduction formları.