SystemVerilog Task ve Function Yapıları

SystemVerilog, tekrar kullanılabilir kod blokları yazmak için task ve function yapıları sunar. Bu yapılar, hem RTL modellemesi hem de testbench geliştirme için sıkça kullanılır. Aritmetik hesaplamalardan tut, stimulus üretimi, zamanlamalı işlemler ve modüller arası iletişime kadar birçok alanda görev alırlar.

📌 Genel Bakış
#

Özellik	Function	Task
Geri dönüş	Tek bir değer döndürür	Geri dönüş yoktur, output parametreleri kullanılır
Zaman	Simülasyon zamanı tüketmez	Simülasyon zamanı tüketebilir (`#`, `@`)
Kullanım	Saf hesaplama	Zamanlama, modül etkileşimi, dosya I/O
Girişler	Sadece `input`	`input`, `output`, `inout` destekler
Çağırma	Fonksiyon gibi çağrılır	Prosedür gibi çağrılır

🧠 Ne Zaman Kullanmalı?
#

Kullanım Durumu	Function mı?	Task mı?
Saf matematiksel işlem	✅
Gecikme kullanımı (`#5`, `@posedge`)		✅
Dosya işlemleri, `$display`, `$fopen`		✅
Birden fazla değer döndürmek		✅
Karşılaştırma, doğrulama, assertion	✅
Clocking block ile senkron kontrol		✅

🔁 Function Sözdizimi
#

Bir function, tek bir değer döndürür ve simülasyon zamanı tüketmez.

function int add(int a, int b);
  return a + b;
endfunction

int result = add(3, 5);

#delay, @, wait gibi zamanlı yapılar içeremez
Sadece bir değer döndürmelidir
Girişler değer olarak (by value) geçilir

🔄 Task Sözdizimi
#

Task, birden fazla değer döndürebilir, gecikme kullanabilir ve daha esnektir.

task automatic delay_and_add(input int a, b, output int sum);
  #5;
  sum = a + b;
endtask

int x;
delay_and_add(2, 3, x);

#, @, wait, $display gibi ifadeler kullanılabilir
Girişler, çıkışlar ve çift yönlü parametreler desteklenir (input, output, inout)
Hiçbir, bir, veya birden fazla değer döndürebilir

📥 Giriş ve Çıkış Parametre Türleri
#

Tür	Açıklama
`input`	Sadece okunabilir, task içinde değişmez
`output`	Task içinde atanır ve çağırana geri döner
`inout`	Çift yönlü, dikkatli kullanılmalıdır

task operate(input int a, inout int b, output int result);
  b += a;
  result = a * b;
endtask

🧠 `automatic` vs `static`
#

Varsayılan olarak Verilog’da tüm task ve function’lar statiktir — çağrılar arasında değişkenler paylaşılır. automatic kullanıldığında her çağrı için ayrı bir yerel yığın (stack) tahsis edilir.

task automatic do_something();
  int counter = 0;
  counter++;
  $display("Counter = %0d", counter);
endtask

✅ automatic ile çağrılar arası çakışmaları ve yan etkileri önlersin. Rekürsif (öz yinelemeli) yapılar için şarttır.

🧪 RTL Tasarımında Function Örneği
#

module alu(input logic [3:0] a, b, output logic [4:0] result);

  function logic [4:0] add;
    input logic [3:0] x, y;
    add = x + y;
  endfunction

  assign result = add(a, b);

endmodule

🧪 Testbench’te Task Örneği
#

task automatic print_banner(string msg);
  $display("\n=====================");
  $display("  %s", msg);
  $display("=====================\n");
endtask

initial begin
  print_banner("Simülasyon Başladı");
end

🚦 Sentez vs Simülasyon
#

Özellik	Sentezlenebilir mi?	Açıklama
Saf hesaplama yapan fonksiyonlar	✅	ALU, karşılaştırıcı, hesaplayıcı yapılarda
Gecikmeli veya `$display` içeren task’lar	❌	Sadece testbench için uygundur
Sadece atama içeren basit task’lar	✅ (dikkatli kullanım)	Statik ve sınırlı olmalıdır

✅ En İyi Kullanım Önerileri
#

Combinational (stateless) mantık için function kullan
Testbench kontrolü ve zamanlı işlemler için task tercih et
Yan etkileri önlemek için automatic kullan
Sentezlenecek kodda task içinde # veya $ ifadelerinden kaçın
Anlaşılır kod için isimli argüman kullanımı önerilir:

my_task(.a(10), .b(20), .result(my_var));

🔚 Özet
#

Anahtar Sözcük	Değer Döndürür mü?	Gecikme Kullanabilir mi?	Çoklu Çıkış?	Nerede Tercih Edilir?
`function`	✅	❌	❌	RTL, hesaplama fonksiyonları
`task`	❌ (output ile)	✅	✅	Testbench, kontrol yapıları

SystemVerilog’taki task ve function yapıları, hem tasarımda hem doğrulamada modüler, yeniden kullanılabilir ve amaç odaklı kodlar yazmanın temelidir.

module tb_task_function_demo;

    // Function: Pure computation
    function automatic int multiply_by_two(int val);
        return val * 2;
    endfunction

    // Task: With delay and multiple outputs
    task automatic compute_delay_add(
        input int a, b,
        output int sum
    );
        #5;
        sum = a + b;
        $display("Delayed Sum = %0d", sum);
    endtask

    // Task: With input, inout, output
    task automatic operate(
        input int a,
        inout int b,
        output int res
    );
        b += a;
        res = a * b;
    endtask

    initial begin
        int result, sum, val = 5, io = 3;

        result = multiply_by_two(val);
        $display("multiply_by_two(%0d) = %0d", val, result);

        compute_delay_add(7, 8, sum);

        operate(2, io, result);
        $display("After operate: io = %0d, result = %0d", io, result);

        $finish;
    end

endmodule