SystemVerilog'da İleri Nesne Yönelimli Programlama: Yapıcılar, Handle'lar ve Statik Üyeler

SystemVerilog Tasarım Serisi - This article is part of a series.

Part 26: This Article

Part 27: SystemVerilog'da İleri OOP: Aggregation, Kalıtım ve Daha Fazlası

Part 28: SystemVerilog'da Polymorphism ve Sanallık (Virtuality)

Part 29: SystemVerilog: Sınıf Tabanlı Randomization ve Constraints

Part 30: SystemVerilog: Covergroups ve Coverage

🛠️ SystemVerilog’ta İleri OOP: Constructor, Handle ve Statik Üyeler
#

Bu bölümde SystemVerilog’un nesne yönelimli programlama (OOP) özelliklerini derinlemesine inceliyoruz: sınıf tanımları, nesne handle yönetimi, constructor kullanımı, external metod tanımları, statik metodlar ve statik değişkenler.

1️⃣ Sınıf Tanımı ve Örneklenmesi
#

SystemVerilog’ta bir sınıf, class anahtar kelimesi ile tanımlanır. Sınıf; veri üyeleri (property) ve metotlar (function/task) içerebilir. Bir sınıftan nesne oluşturmak için new() operatörü kullanılır.

Örnek:

class Packet;
  bit [7:0] data;
  function void print();
    $display("Data: %0h", data);
  endfunction
endclass

Packet pkt;
initial begin
  pkt = new(); // Packet sınıfından nesne oluşturma
  pkt.data = 8'hAB;
  pkt.print();
end

2️⃣ Sınıf Handle’ları ve Nesneler
#

SystemVerilog’ta sınıflara handle aracılığıyla erişilir. Handle, bellekteki bir nesneye işaret eden değişkendir.

Class handle: Sınıf türünde bir değişken, örn. Packet pkt;
Object: new() kullanılarak oluşturulan gerçek nesnedir.

Handle’lar:

Birbirine atanabilir (aynı nesneyi paylaşır).
null ile karşılaştırılarak nesnenin oluşturulup oluşturulmadığı kontrol edilebilir.

Örnek:

Packet pkt1, pkt2;
pkt1 = new();
pkt2 = pkt1; // pkt1 ve pkt2 aynı nesneyi işaret eder

3️⃣ Geçerli Nesne Handle’ı (`this`)
#

this anahtar kelimesi, geçerli nesneyi temsil eder.

Örnek:

class Packet;
  bit [7:0] data;
  function void show();
    $display("Bu paketteki data: %0h", this.data);
  endfunction
endclass

this, özellikle metodlar içinde nesne ile ilgili işlemleri yaparken veya parametre isimleri ile nesne üyeleri çakıştığında kullanışlıdır.

4️⃣ Constructor Metodu
#

Bir constructor, bir nesne oluşturulduğunda çalışan ve genellikle new() ismiyle tanımlanan özel bir metottur. Başlangıç değerleri atamak için kullanılabilir.

Örnek:

class Packet;
  bit [7:0] data;
  function new(bit [7:0] init_data);
    data = init_data;
  endfunction
endclass

Packet pkt = new(8'hFF); // data 8'hFF ile başlatılır

Constructor tanımlanmazsa SystemVerilog, parametresiz default bir new() metodu oluşturur.

5️⃣ External Metod Tanımlama
#

SystemVerilog’ta bir metot sınıf içinde bildirilebilir, ancak sınıf dışında tanımlanabilir. Bu özellik büyük testbenchlerde kodun daha düzenli tutulmasına yardımcı olur.

Örnek:

class Packet;
  bit [7:0] data;
extern function void print();
endclass

function void Packet::print();
  $display("Data = %0h", data);
endfunction

Sınıf dışı tanımlarda SınıfAdı::MetotAdı şeklinde yazılır.

6️⃣ `super` Anahtar Kelimesi
#

super, bir alt sınıfın üst sınıfındaki metotları veya constructor’ı çağırmasını sağlar.

Örnek:

class BasePacket;
  function void display();
    $display("Base display");
  endfunction
endclass

class DataPacket extends BasePacket;
  function void display();
    super.display(); // Üst sınıf display metodunu çağırır
    $display("DataPacket display");
  endfunction
endclass

7️⃣ Statik Sınıf Metotları
#

Statik metotlar, bir sınıfa aittir ve herhangi bir nesneye bağlı değildir. Bu metotlar nesneye özel değişkenlere erişemez.

Örnek:

class Utility;
  static function void showHelp();
    $display("Bu bir statik yardım metodudur.");
  endfunction
endclass

initial begin
  Utility::showHelp(); // Statik metodu çağırma
end

8️⃣ Statik Sınıf Değişkenleri
#

Statik değişkenler, sınıfa aittir ve o sınıftan oluşturulan tüm nesneler tarafından paylaşılır.

Örnek:

class Counter;
  static int count = 0;

  function void increment();
    count++;
  endfunction

  static function void showCount();
    $display("Count = %0d", count);
  endfunction
endclass

initial begin
  Counter c1 = new();
  Counter c2 = new();
  c1.increment();
  c2.increment();
  Counter::showCount(); // Çıktı: 2
end

📖 Sonuç
#

Bu ileri OOP özellikleri, SystemVerilog ile daha modüler, sürdürülebilir ve ölçeklenebilir testbench’ler geliştirmenize yardımcı olur. Bu kavramları ustalıkla kullanmak, doğrulama ortamlarınızı çok daha güçlü hale getirecektir.

module tb_advanced_oop_demo;

  // Base class with data and constructor
  class Packet;
    bit [7:0] data;

    // Constructor with argument
    function new(bit [7:0] init_data);
      data = init_data;
    endfunction

    // Print method declared inside, defined outside
   extern function void print();
  endclass

  // Print method defined outside the class
  function void Packet::print();
    $display("[Packet] Data = %0h", data);
  endfunction

  // Derived class extending Packet
  class ExtendedPacket extends Packet;
    bit [7:0] id;

    function new(bit [7:0] init_data, bit [7:0] init_id);
      super.new(init_data);
      id = init_id;
    endfunction

    function void print();
      super.print();
      $display("[ExtendedPacket] ID = %0h", id);
    endfunction
  endclass

  // Class with static property and method
  class Counter;
    static int count = 0;

    function void increment();
      count++;
    endfunction

    static function void showCount();
      $display("Count = %0d", count);
    endfunction
  endclass

  initial begin
    Packet p;
    ExtendedPacket ep;
    Counter c1;
    Counter c2;

    // Object creation and assignments
    p = new(8'hAA);
    p.print();

    ep = new(8'hBB, 8'h01);
    ep.print();

    // 'this' example
    $display("Accessing 'this.data' in Packet: %0h", p.data);

    // Static counter demonstration
    c1 = new();
    c2 = new();
    c1.increment();
    c2.increment();
    Counter::showCount();

    #10 $finish;
  end

endmodule