SystemVerilog Veri Türleri

SystemVerilog, Verilog-2001 ve daha önceki sürümlerle geriye dönük uyumluluk sağlamak için Verilog’un tüm veri türlerini destekler. Ancak modern projelerde SystemVerilog türleri tercih edilmelidir. Aşağıda, hala karşılaşabileceğiniz bazı legacy veri türleri ve yerlerine kullanılabilecek SystemVerilog türleri listelenmiştir:

📘 Önceki Rehber: 👉 Verilog Veri Türleri Rehberi sayfasını inceleyebilirsiniz.

📜 Legacy Veri Türleri Tablosu
#

Verilog Türü	SystemVerilog Karşılığı	Kullanım Durumu	Notlar
`reg`	`logic`	⚠️ Eskidi	RTL’de `logic` tercih edilmeli (sentezlenebilirlik + okunabilirlik)
`wire`	`logic` veya `wire`	⚠️ Karma Kullanım	`wire`: sadece net bağlantılarında çoklu sürücü için kullanılır
`integer`	`int`	⚠️ Kısıtlı	32-bit signed, `int` ile aynı; modern kodlarda `int` tercih edilmeli
`time`	`longint`	🧪 Simülasyon içi	Simülasyon zamanı ölçümü için özel; sentezlenemez
`real`	`real`, `shortreal`	🧪 Simülasyon içi	`real`: 64-bit, `shortreal`: 32-bit; sadece testbench kullanımı için

graph LR
A[SystemVerilog Türleri] --> B[Temel Skaler]
A --> C[Bileşik Yapılar]
B --> D[bit, logic, int]
C --> E[struct, union]
C --> F[array, queue]

Tipler
#

Tip	Durumlar	Boyut	İşaretli mi	Varsayılan Değer	Kategori	Açıklamalar
`bit`	0, 1	1-bit (skaler veya paketli)	Hayır	`0`	2 Durumlu	Simülasyonlarda veya X/Z gerekmediğinde kullanılır
`logic`	0, 1, X, Z	1-bit (skaler veya paketli)	Hayır	`X`	4 Durumlu	`reg` yerine tercih edilir; RTL için sentezlenebilir
`reg`	0, 1, X, Z	1-bit (skaler veya paketli)	Hayır	`X`	4 Durumlu	Eski tür; modern kodda `logic` ile değiştirilmelidir
`byte`	—	8-bit	Evet	`0`	Tamsayı	Varsayılan olarak işaretlidir
`shortint`	—	16-bit	Evet	`0`	Tamsayı
`int`	—	32-bit	Evet	`0`	Tamsayı	En yaygın tamsayı türü
`longint`	—	64-bit	Evet	`0`	Tamsayı
`integer`	—	≥32-bit (uyg. bağlı)	Evet	`0`	Tamsayı	Verilog’tan kalma tür; `int` veya `longint` tercih edin
`time`	—	64-bit	Hayır	`0`	Zamanlama	Simülasyon zaman takibi için kullanılır
`string`	—	Dinamik uzunluk	—	`""`	Karakter Dizisi	`.len()`, `.putc()` gibi metodları destekler

🔄 `reg` vs `logic`
#

// Verilog tarzı
reg [7:0] counter;  // Yalnızca procedural bloklarda kullanılır

// SystemVerilog tarzı
logic [7:0] counter; // assign + always bloklarında kullanılabilir

✅ logic, hem RTL uyumluluğu hem de analiz araçları açısından daha tutarlıdır. ❌ reg, artık modern RTL’de önerilmez.

🔌 `wire` Kullanımında Kurallar
#

module example(
  input  wire a,      // Eski alışkanlık olarak portta kullanılır
  output logic b      // Modern çıkış tipi
);
  wire c;             // Çoklu driver gerekiyorsa kullanılabilir
  assign c = a & b;

  logic d;            // Dahili sinyaller için daha uygundur
endmodule

🎯 Kural: Sadece çoklu sürücü gereken yerlerde wire kullan. Tek sürücülü sinyallerde logic kullanımı daha güvenli ve okunaklıdır.

📅 Veri Türü Geçiş Tablosu
#

Kullanım Amacı	Eski Tür (`Verilog`)	Önerilen Tür (`SystemVerilog`)
RTL sinyal tanımı	`reg`	`logic`
Sayaç, sayaç değişkeni	`integer`	`int` veya `bit [31:0]`
Kayan nokta işlem	`real`	`shortreal` (32-bit)
Donanım bağlantısı	`wire`	`logic` (tek driver) veya `wire`

🧪 Örnek: Eski ve Yeni Türlerin Birlikte Kullanımı
#

module legacy_mix(
  input  wire clk,           // Eski stil giriş
  output logic [3:0] data    // Yeni stil çıkış
);
  integer i;                 // Verilog'tan kalma tür
  bit [31:0] j;              // SystemVerilog unsigned türü

  always_ff @(posedge clk) begin
    i = -1;   // signed
    j = i;    // signed → unsigned dönüşümü
  end
endmodule

🧠 integer ve int ikisi de 32-bit signed’dır ama int modern ve net bir tercihtir. bit sadece 0/1 içerir; 4-state gerekmediği durumlarda tercih edilir.

⚠️ Dikkat Edilmesi Gerekenler
#

integer İşaretli Olduğu İçin Tuzak Olabilir

integer i = 32'hFFFF_FFFF; // = -1 olarak değerlendirilir
bit [31:0] b = i;          // b = 32'hFFFF_FFFF, ama işaretli → işaretsiz dönüşüm

real Değerler Sentezlenemez
- Sadece testbenchlerde kullanılmalı.
- Sentez araçları real türünü desteklemez.

🛠️ FPGA İçin `logic` Başlangıç Değeri ve `multiple drivers` Hatası
#

  logic [7:0] x;
  initial x = 8'hFF;
  always_ff @(posedge clk)
    x <= x + 1;

❗ Yukarıdaki örnekte, logic türüne initial içinde hem başlangıç değeri (= 8'hFF) atanmış, hem de always_ff bloğunda tekrar değer atanıyor. ⚠️ always_ff içerisinde atana yapılmış bir değişkene başka bir işlem bloğunda atama yapılamaz. ✅ Bu tür durumlarda:
  logic [7:0] x;
  initial x = 8'hFF;
  always @(posedge clk)
    x <= x + 1;

✅ Modern Kodlama İçin Tavsiyeler
#

RTL kodlarında logic kullan (reg yerine).
Testbench yazarken bit, int gibi 2-state türleri tercih et (performans ve sade analiz için).
wire sadece gerektiğinde (çoklu sürücü, modül dışı bağlantı) kullanılsın.
integer yerine int, real yerine shortreal tercih et (özellikle yeni projelerde).
FPGA için başlangıç değerli logic tanımlarında sentez hatalarına dikkat et.

module datatype_testbench;

  // Veri tipi tanımlamaları
  bit         b;          // 2 durumlu, sadece 0 veya 1
  logic       l;          // 4 durumlu, 0/1/X/Z olabilir
  reg         r;          // Eski stil 4 durumlu kayıt
  wire        w;          // Net tipi, bir kaynak tarafından sürülmeli
  byte        bt;         // 8 bit signed
  shortint    si;         // 16 bit signed
  int         i;          // 32 bit signed
  longint     li;         // 64 bit signed
  integer     old_i;      // Eski stil signed integer (en az 32 bit)
  time        t;          // Simülasyon zamanı (64 bit)
  real        real_val;   // 64 bit kayan nokta (float)
  shortreal   sreal_val;  // 32 bit kısa float
  string      str;        // Dinamik uzunluklu karakter dizisi

  assign w = b; // wire tipi bir kaynak tarafından sürülmelidir

  initial begin
    // Başlangıç varsayılan değerleri
    $display("----- [Başlangıç Varsayılan Değerleri] -----");
    $display("bit         = %b", b);
    $display("logic       = %b", l);
    $display("reg         = %b", r);
    $display("wire        = %b", w);
    $display("byte        = %0d", bt);
    $display("shortint    = %0d", si);
    $display("int         = %0d", i);
    $display("longint     = %0d", li);
    $display("integer     = %0d", old_i);
    $display("time        = %0t", t);
    $display("real        = %0f", real_val);
    $display("shortreal   = %0f", sreal_val);
    $display("string      = \"%s\" (uzunluk = %0d)", str, str.len());

    #5; // 5 zaman birimi bekle

    // Signed (işaretli) değerleri ata
    b         = -1'b1;
    l         = -1'b1;
    r         = -1'b1;
    bt        = -8'sd100;
    si        = -16'sd30000;
    i         = -32'sd12345678;
    li        = -64'sd1234567890123456;
    old_i     = -42;
    t         = -64'd500;
    real_val  = -3.141592;
    sreal_val = -2.71;
    str       = "SystemVerilog";

    $display("\n----- [Atanmış Signed Değerler] / Signed ise negatif olmalıdır -----");
    $display("bit         = %b", b);
    $display("logic       = %b", l);
    $display("reg         = %b", r);
    $display("wire        = %b", w);
    $display("byte        = %0d", bt);
    $display("shortint    = %0d", si);
    $display("int         = %0d", i);
    $display("longint     = %0d", li);
    $display("integer     = %0d", old_i);
    $display("time        = %0t", t);
    $display("real        = %0f", real_val);
    $display("shortreal   = %0f", sreal_val);
    $display("string      = \"%s\" (uzunluk = %0d)", str, str.len());

    // $bits() ile bit genişliklerini göster
    $display("\n----- [$bits() ile Bit Genişlikleri] -----");
    $display("$bits(bit)         = %0d", $bits(b));
    $display("$bits(logic)       = %0d", $bits(l));
    $display("$bits(reg)         = %0d", $bits(r));
    $display("$bits(byte)        = %0d", $bits(bt));
    $display("$bits(shortint)    = %0d", $bits(si));
    $display("$bits(int)         = %0d", $bits(i));
    $display("$bits(longint)     = %0d", $bits(li));
    $display("$bits(integer)     = %0d", $bits(old_i));
    $display("$bits(time)        = %0d", $bits(t));
    $display("real               = %0d", $bits(real_val));
    $display("shortreal          = %0d", $bits(sreal_val));
    $display("string             = \"%0d\" (uzunluk = %0d)", $bits(str), str.len());
    // Not: $bits() 'real', 'shortreal' için geçerli değildir
  end

endmodule

📤 Output:
#

# ----- [Initial Default Values] -----
# bit         = 0
# logic       = x
# reg         = x
# wire        = x
# byte        = 0
# shortint    = 0
# int         = 0
# longint     = 0
# integer     = x
# time        = 0
# real        = 0.000000
# shortreal   = 0.000000
# string      = "" (length = 0)
# 
# ----- [Assigned Signed Values] / If signed it should negative -----
# bit         = 1
# logic       = 1
# reg         = 1
# wire        = 0
# byte        = -100
# shortint    = -30000
# int         = -12345678
# longint     = -1234567890123456
# integer     = -42
# time        = -500
# real        = -3.141592
# shortreal   = -2.710000
# string      = "SystemVerilog" (length = 13)
# 
# ----- [Bit Widths Using $bits()] -----
# $bits(bit)         = 1
# $bits(logic)       = 1
# $bits(reg)         = 1
# $bits(byte)        = 8
# $bits(shortint)    = 16
# $bits(int)         = 32
# $bits(longint)     = 64
# $bits(integer)     = 32
# $bits(time)        = 64
# real               = 0
# shortreal          = 0
# string             = "104" (uzunluk = 13)