Introduction to Inter-Process Communication

// ── Without IPC: two threads updating a shared counter ────────
int shared_count = 0;
 
initial fork
    begin : thread_a
        repeat (1000) begin
            shared_count++;      // READ-MODIFY-WRITE — not atomic
            #1;
        end
    end
    begin : thread_b
        repeat (1000) begin
            shared_count++;      // Thread B races thread A
            #1;
        end
    end
join
// Expected: 2000.  Actual: anywhere from 1000 to 2000. Non-deterministic.
 
// ── With a semaphore: protected critical section ──────────────
semaphore count_lock = new(1);   // 1 key = binary semaphore (mutex)
 
initial fork
    begin : thread_a_safe
        repeat (1000) begin
            count_lock.get();    // acquire the key — wait if taken
            shared_count++;
            count_lock.put();    // release the key
            #1;
        end
    end
    begin : thread_b_safe
        repeat (1000) begin
            count_lock.get();
            shared_count++;
            count_lock.put();
            #1;
        end
    end
join
// Result: always exactly 2000. Deterministic.

// ── Declare a shared event ────────────────────────────────────
event pkt_sent;     // any process can trigger or wait on this
 
initial fork
 
    // ── Driver process: sends a packet then fires the event ───
    begin : driver
        send_packet();          // task that drives the DUT
        ->pkt_sent;             // trigger: "I just sent one"
        $display("[DRV] Packet sent and event triggered at %0t", $time);
    end
 
    // ── Scoreboard process: waits for the event, then checks ──
    begin : scoreboard
        @pkt_sent;              // block until driver fires ->pkt_sent
        check_output();         // now safe to compare DUT output
        $display("[SB] Check triggered by event at %0t", $time);
    end
 
join

// ── One key = only one driver on the bus at a time ────────────
semaphore bus_lock = new(1);
 
task automatic drive_bus(string name, int n_transactions);
    repeat (n_transactions) begin
        bus_lock.get();                         // acquire — block if busy
        $display("[%s] Acquired bus at %0t", name, $time);
        drive_transaction();                     // access the bus
        bus_lock.put();                         // release for the other driver
        $display("[%s] Released bus at %0t", name, $time);
    end
endtask
 
initial fork
    drive_bus("DRV-A", 5);    // 5 transactions from driver A
    drive_bus("DRV-B", 5);    // 5 transactions from driver B
join
// Result: DRV-A and DRV-B take turns. They never collide on the bus.

// ── Shared mailbox: generator puts, driver gets ───────────────
mailbox #(ApbTransaction) gen2drv = new();   // unbounded, typed
 
initial fork
 
    // ── Generator: creates transactions and puts them in the mailbox
    begin : generator
        repeat (20) begin
            ApbTransaction t = new();
            void'(t.randomize());
            gen2drv.put(t);                 // put into the queue — never blocks (unbounded)
            $display("[GEN] Put txn id=%0d", t.id);
        end
    end
 
    // ── Driver: picks up transactions and drives them to the DUT
    begin : driver
        ApbTransaction t;
        forever begin
            gen2drv.get(t);             // get — blocks if mailbox is empty
            drive_apb(t);               // drive to DUT at the bus speed
            $display("[DRV] Drove txn id=%0d at %0t", t.id, $time);
        end
    end
 
join_any
// Generator finishes in 20 iterations; driver runs until generator is done.

event done;
 
// ── Buggy: producer wins the race, consumer hangs ────────────
initial fork
    begin : producer
        #10;
        ->done;                       // fires at t=10
    end
    begin : consumer
        #20;                          // consumer starts late
        @done;                        // waits for NEXT trigger — never comes
        $display("never printed");
    end
join
 
// ── Fix #1: wait(e.triggered) — persistent flag for the full step
@(posedge clk);
wait(done.triggered);          // true if done fired anywhere in THIS step
 
// ── Fix #2: NBA trigger ->> defers the trigger to the NBA region
->>done;                       // consumer reaching @done in Active region still sees it
 
// ── Fix #3: replace the event with a handshake mailbox
mailbox #(int) hs = new(1);    // bounded(1): put blocks until consumed
hs.put(1);                     // producer
hs.get(dummy);                 // consumer — never misses

// AXI4 master allowed up to 4 outstanding read requests at once.
semaphore outstanding_reads = new(4);   // 4 credits
 
task automatic issue_read(AxiRdReq r);
    outstanding_reads.get();             // blocks if 4 already in flight
    drive_ar_channel(r);
    // the R-channel monitor calls .put() when the response arrives:
endtask
 
task automatic read_resp_done();
    outstanding_reads.put();             // release one credit
endtask

// ── Shared IPC objects (declared at environment level) ────────
mailbox #(ApbTxn) gen2drv   = new();    // generator  → driver
mailbox #(ApbTxn) mon2sb    = new();    // monitor    → scoreboard
mailbox #(ApbTxn) ref2sb    = new();    // ref model  → scoreboard
semaphore         bus_lock  = new(1);   // one agent on bus at a time
event             test_done;            // generator fires when all txns created
 
// ── Component tasks (simplified) ──────────────────────────────
task generator();
    repeat (100) begin
        ApbTxn t = new(); void'(t.randomize());
        gen2drv.put(t);                  // mailbox → driver
        ref2sb.put(t);                   // mailbox → reference model input
    end
    ->test_done;                          // event → test done
endtask
 
task driver();
    ApbTxn t;
    forever begin
        gen2drv.get(t);                  // wait for mailbox item
        bus_lock.get();                   // semaphore → exclusive bus access
        drive_apb(t);
        bus_lock.put();                   // release bus
    end
endtask
 
task monitor();
    ApbTxn t;
    forever begin
        sample_apb(t);
        mon2sb.put(t);                   // mailbox → scoreboard
    end
endtask
 
task scoreboard();
    ApbTxn expected, actual;
    forever begin
        ref2sb.get(expected);            // wait for reference
        mon2sb.get(actual);              // wait for actual
        compare(expected, actual);
    end
endtask
 
// ── Top-level test ────────────────────────────────────────────
initial begin
    fork
        generator();
        driver();
        monitor();
        scoreboard();
    join_any                              // run until generator fires test_done
    @test_done;                           // event → wait for all txns generated
    #1000;                                // drain the pipeline
    $finish;
end

// ── Events ────────────────────────────────────────────────────
event  e;                    // declaration
->e;                         // trigger (fires and returns immediately)
->>e;                        // non-blocking trigger (scheduled in NBA region)
@e;                          // wait for the NEXT trigger of e (blocking)
wait(e.triggered);           // true if e was triggered THIS time step (non-blocking)
 
// ── Semaphores ────────────────────────────────────────────────
semaphore s = new(N);        // N initial keys
s.get(k);                    // get k keys — blocks if unavailable (default k=1)
s.put(k);                    // return k keys                         (default k=1)
int ok = s.try_get(k);       // non-blocking get: returns 1 on success, 0 if unavailable
 
// ── Mailboxes ─────────────────────────────────────────────────
mailbox          mb  = new();     // untyped, unbounded
mailbox          mb  = new(N);    // untyped, bounded (N slots)
mailbox #(MyType) mb = new();     // typed, unbounded
mb.put(item);                // put — blocks if full (bounded)
mb.get(item);                // get — blocks if empty
mb.peek(item);               // peek — like get but does NOT remove from queue
int ok = mb.try_get(item);   // non-blocking get: 1=success, 0=empty
int ok = mb.try_put(item);   // non-blocking put: 1=success, 0=full
int n  = mb.num();           // number of items currently in the mailbox
 
// ── Decision ──────────────────────────────────────────────────
// No data, just a signal   → event
// Protect shared resource  → semaphore
// Pass data between procs  → mailbox