Integer Types

// ── 2-STATE C-STYLE TYPES ─────────────────────────────────────────
byte         b       = 8'h41;    // 'A' in ASCII — 8-bit signed
shortint     si      = -1000;   // 16-bit signed
int          i       = 0;        // 32-bit signed — standard loop/counter type
longint      li      = 0;        // 64-bit signed — for timestamps, large counts
 
// Unsigned variants of C-style types
byte unsigned     ub = 255;      // 0 to 255
shortint unsigned us = 65535;   // 0 to 65535
int unsigned      ui = 4294967295; // 0 to 4,294,967,295
longint unsigned  ul = 0;        // 0 to 18.4×10^18
 
// ── 4-STATE LEGACY TYPES ──────────────────────────────────────────
integer      legacy  = 0;        // 32-bit 4-state signed — avoid in new SV
time         ts;                  // 64-bit 4-state unsigned — starts as X
ts = $time;                       // capture current simulation time
 
// ── OVERFLOW BEHAVIOR — wraps around ─────────────────────────────
byte  bmax = 127;
bmax++;                           // bmax becomes -128 (wraps to min)
 
int   imax = 2147483647;
imax++;                           // imax becomes -2147483648 (wraps)
 
// ── TYPE DETERMINES ARITHMETIC CONTEXT ───────────────────────────
byte x = 100, y = 100;
int  result;
result = x + y;                   // 200 — promoted to int for arithmetic
byte bresult = x + y;             // -56 — truncated back to byte (overflow!)
 
// ── Signed division truncates toward zero (C behavior) ───────────
int a = -7, b_div = 2;
$display("-7 / 2 = %0d", a / b_div);   // -3 (truncate, not floor)

module tb_integer_types;
 
byte       b  = 0;
shortint   si = 0;
int        i  = 0;
longint    li = 0;
integer    ig;        // 4-state: starts as X
time       ts;        // 4-state: starts as X
 
initial begin
 
// ── Initialization differences ────────────────────────────────
$display("byte  init: %0d", b);    // 0
$display("int   init: %0d", i);    // 0
$display("integer init: %0d", ig); // X
$display("time  init: %0d", ts);   // X
 
// ── byte overflow ─────────────────────────────────────────────
b = 127;
b++;
$display("byte 127+1 = %0d", b);   // -128 (wraps)
b = -128;
b--;
$display("byte -128-1 = %0d", b);  // 127 (wraps from min to max)
 
// ── int vs integer behavior ───────────────────────────────────
ig = ig + 1;
$display("X + 1 (integer) = %0d", ig);  // X — arithmetic with X stays X
i  = i + 1;
$display("0 + 1 (int)     = %0d", i);   // 1 — clean arithmetic
 
// ── Signed division truncates toward zero ─────────────────────
$display("-7 / 2  = %0d", -7 / 2);   // -3 (not -4 like floor division)
$display("-7 %% 2 = %0d", -7 % 2);   // -1 (sign follows dividend)
 
// ── time type for simulation timestamps ───────────────────────
ts = $time;
$display("Sim time = %0t ns", ts);
 
$finish;
end
 
endmodule

byte  init: 0
int   init: 0
integer init: x
time  init: x
byte 127+1 = -128
byte -128-1 = 127
X + 1 (integer) = x
0 + 1 (int)     = 1
-7 / 2  = -3
-7 % 2 = -1
Sim time = 0 ns

module tb_cycle_counter;
 
logic     clk = 0;
longint   cycle_count = 0;    // 64-bit: won't overflow in any real test
longint   txn_start_cycle;
longint   txn_end_cycle;
int       latency;              // 32-bit is enough for latency in cycles
 
always #5 clk = ~clk;           // 10ns period
 
always @(posedge clk)
cycle_count++;                 // count every rising edge
 
initial begin
 
// Simulate sending a transaction and measuring latency
@(posedge clk); txn_start_cycle = cycle_count;
$display("Transaction sent at cycle %0d", txn_start_cycle);
 
// Wait 15 cycles to simulate DUT processing
repeat(15) @(posedge clk);
 
txn_end_cycle = cycle_count;
latency = int'(txn_end_cycle - txn_start_cycle);
$display("Response at cycle %0d, latency = %0d cycles",
txn_end_cycle, latency);
 
// Demonstrate why int would fail for large cycle counts
int     int_count  = 2147483647;  // max int
longint long_count = 2147483647;
int_count++;   // wraps to -2147483648!
long_count++;  // 2147483648 — correct
$display("int overflow:  %0d", int_count);   // -2147483648
$display("longint safe:  %0d", long_count);  // 2147483648
 
$finish;
end
 
endmodule

class axi_scoreboard;
 
int      total_txns   = 0;   // transaction count — 32-bit plenty
int      pass_count   = 0;
int      fail_count   = 0;
longint  total_bytes  = 0;   // byte count — use longint, can exceed 2B
longint  start_time;          // simulation timestamp
int      max_latency  = 0;
int      min_latency  = 2147483647;  // initialize to max so first real value wins
 
function void record_txn(logic [31:0] data, int latency_cycles, int byte_count);
total_txns++;
total_bytes += byte_count;  // longint += int: safe widening
if (latency_cycles > max_latency) max_latency = latency_cycles;
if (latency_cycles < min_latency) min_latency = latency_cycles;
endfunction
 
function void print_summary();
longint elapsed = $time - start_time;
$display("=== Scoreboard Summary ===");
$display("Transactions:  %0d",   total_txns);
$display("Pass / Fail:   %0d / %0d", pass_count, fail_count);
$display("Total bytes:   %0d",   total_bytes);
$display("Latency min/max: %0d / %0d cycles", min_latency, max_latency);
$display("Test duration: %0d ns", elapsed);
endfunction
 
endclass
 
module tb_sb_demo;
initial begin
axi_scoreboard sb = new();
sb.start_time = $time;
sb.record_txn(32'hABCD, 5, 64);
sb.record_txn(32'h1234, 12, 128);
sb.record_txn(32'hFFFF, 3, 32);
#100;
sb.print_summary();
$finish;
end
endmodule

module tb_signed_traps;
 
initial begin
 
// ── byte is signed — max is 127, not 255 ─────────────────────
byte b = 200;    // DANGEROUS: 200 > 127, assigned as -56!
$display("byte = 200 stored as: %0d", b);  // -56
 
byte unsigned ub = 200;   // OK: 200 fits in 0..255
$display("byte unsigned = 200: %0d", ub);  // 200
 
// ── Mixing signed and unsigned in comparison ──────────────────
int          si = -1;
int unsigned ui = 1;
// When int and int unsigned are compared, int is promoted to unsigned
// -1 as int = 0xFFFFFFFF as unsigned = 4294967295
if (si > ui)
$display("-1 > 1 = TRUE (signed -1 promoted to uint!)");  // prints
// Use $signed() and $unsigned() casts to control interpretation
if ($signed(si) > $signed(ui))
$display("-1 > 1 with signed context = still wrong cast");
// Correct: compare same types
int ui_as_int = int'(ui);
if (si > ui_as_int)
$display("-1 > 1 signed: TRUE (same type)");    // -1 > 1 is false
else
$display("-1 < 1 signed: correct");               // prints
 
// ── Widening assignment: always safe ─────────────────────────
byte    small = 100;
int     wide  = small;     // 100 sign-extended to 32-bit: 100
$display("byte 100 → int: %0d", wide);  // 100
 
small = -10;
wide  = small;             // -10 sign-extended: -10
$display("byte -10 → int: %0d", wide);  // -10 (sign preserved)
 
// ── Narrowing: may lose bits ──────────────────────────────────
int  big = 300;
byte narrow = byte'(big);  // explicit cast: 300 truncated to 8 bits
$display("int 300 → byte: %0d", narrow);  // 44 (300 = 256+44, lower 8 bits)
 
$finish;
end
 
endmodule

byte = 200 stored as: -56
byte unsigned = 200: 200
-1 > 1 = TRUE (signed -1 promoted to uint!)
-1 < 1 signed: correct
byte 100 → int: 100
byte -10 → int: -10
int 300 → byte: 44

// ── 1. LOOP VARIABLES: int is the standard ────────────────────────
for (int i = 0; i < 256; i++)
$display("addr[%0d] = %h", i, mem[i]);
 
// ── 2. FOREACH INDEX: automatic int ──────────────────────────────
foreach (arr[i])    // i is implicitly int — no declaration needed
arr[i] = i * 2;
 
// ── 3. TRANSACTION COUNTER: int sufficient ────────────────────────
int  txn_id = 0;
function int next_id(); return txn_id++; endfunction
 
// ── 4. BYTE BUFFER: byte type for memory-efficient arrays ─────────
byte packet_buf [1024];    // 1KB buffer — 1/4 of int array memory
 
// ── 5. SIMULATION TIMESTAMP: longint ─────────────────────────────
longint sim_start, sim_end;
// initial: sim_start = $time;
// final:   sim_end = $time; $display("Total sim: %0dns", sim_end - sim_start);
 
// ── 6. LATENCY MEASUREMENT: int ───────────────────────────────────
longint req_time, resp_time;
int     latency_ns;
// req_time = $time;
// ... wait for response ...
// resp_time = $time;
// latency_ns = int'(resp_time - req_time);
 
// ── 7. COVERAGE BINS: int for hit counts ──────────────────────────
int opcode_hits [256];    // how many times each opcode was seen
// opcode_hits[op]++; — simple and safe
 
// ── 8. CONSTRAINT: int works natively ────────────────────────────
class rand_txn;
rand int unsigned burst_len;
constraint len_c { burst_len inside {[1:256]}; }
endclass

// BUGGY: integer is 4-state, starts as X
integer i;   // i = X at start — NOT zero!
for (i = 0; i < 10; i++)   // explicitly initialized: this is OK
$display("%0d", i);       // works fine when initialized in for()
 
// The dangerous case:
integer count;  // count = X
while (count < 10)    // X < 10 → evaluates to X → treated as false!
count++;              // NEVER EXECUTES — loop body skipped entirely
$display("count = %0d", count);  // still X
 
// FIXED: use int (always 0) or initialize explicitly
int safe_count;         // = 0 automatically
while (safe_count < 10)
safe_count++;          // runs 10 times correctly

int     cycle_cnt = 0;         // BUGGY for long tests
always @(posedge clk) cycle_cnt++;
 
// After 2,147,483,647 cycles, cycle_cnt wraps to -2,147,483,648
// Any latency check now produces negative or garbage values
// Symptom: "latency = -2145899123 cycles" in the log
 
// FIXED: use longint — wraps after 9.2×10^18 cycles (never in practice)
longint safe_cycle_cnt = 0;
always @(posedge clk) safe_cycle_cnt++;

// BUGGY: engineer thinks byte is unsigned (like hardware 8-bit)
byte status_code = 200;   // 200 → stored as -56 (signed overflow)
 
if (status_code == 200)
$display("Got status 200");   // NEVER fires — code is -56, not 200
else if (status_code == -56)
$display("Got status -56");   // fires unexpectedly
 
// FIXED option 1: use byte unsigned for 0..255 range
byte unsigned status_ok = 200;  // 200 stored as 200
if (status_ok == 200) $display("Got 200");  // works
 
// FIXED option 2: use int for general-purpose 8-bit values in TB
// Rarely worth using byte at all in TB — int is simpler and avoids confusion

int          signed_val   = -1;
int unsigned unsigned_val = 1;
 
// BUGGY COMPARISON: mixing signed and unsigned
// signed_val is promoted to unsigned → -1 becomes 4294967295
if (signed_val > unsigned_val)
$display("-1 > 1 is TRUE!");    // prints — promotion made -1 = 0xFFFFFFFF
 
// CORRECT: compare same types or use explicit cast
if ($signed(signed_val) > $signed(unsigned_val))
$display("Signed: -1 > 1");   // false — correct behavior
else
$display("Signed: -1 < 1 — correct");  // prints
 
// GOLDEN RULE: never mix signed and unsigned in comparisons
// Cast explicitly or use the same signedness consistently