10메모리와 FIFO

// 4 x 8 레지스터 파일. 쓰기 포트 하나, 주소 하나를 두 방식으로 읽는다.
module regfile (
  input            clock,
  input            we,
  input      [1:0] waddr,
  input      [7:0] wdata,
  input      [1:0] raddr,
  output     [7:0] rdata_async,
  output reg [7:0] rdata_sync
);
  reg [7:0] mem [0:3];

  // 쓰기는 상승 에지에서만 일어난다.
  always @(posedge clock) begin
    if (we) mem[waddr] <= wdata;
    // 레지스터를 거친 읽기. raddr의 워드를 에지에서 샘플링해 저장한다.
    rdata_sync <= mem[raddr];
  end

  // 비동기 읽기. rdata_async는 raddr와 mem을 바로 따른다.
  assign rdata_async = mem[raddr];
endmodule

// WIDTH비트 워드 DEPTH개를 담는 동기 FIFO.
module sync_fifo #(
  parameter WIDTH = 8,
  parameter DEPTH = 4
) (
  input              clock,
  input              reset,
  input              push,
  input  [WIDTH-1:0] din,
  input              pop,
  output [WIDTH-1:0] dout,
  output             full,
  output             empty,
  output reg   [4:0] count
);
  reg [WIDTH-1:0] mem [0:DEPTH-1];
  // 포인터를 직접 되돌리므로 DEPTH가 2의 거듭제곱일 필요는 없다(최대 16).
  reg [3:0] wr_ptr, rd_ptr;

  // 가득 찼을 때의 push와 비었을 때의 pop은 무시한다.
  wire do_push = push && !full;
  wire do_pop  = pop  && !empty;

  always @(posedge clock) begin
    if (reset) begin
      wr_ptr <= 4'd0;
      rd_ptr <= 4'd0;
      count  <= 5'd0;
    end else begin
      if (do_push) begin
        mem[wr_ptr] <= din;
        wr_ptr <= (wr_ptr == DEPTH - 1) ? 4'd0 : wr_ptr + 4'd1;
      end
      if (do_pop)
        rd_ptr <= (rd_ptr == DEPTH - 1) ? 4'd0 : rd_ptr + 4'd1;
      // push와 pop이 둘 다 허용되면 한 워드가 들어오고 한 워드가 나가므로 count는 그대로다.
      count <= count + do_push - do_pop;
    end
  end

  // 비어 있지 않으면 가장 오래된 워드가 비동기 읽기로 dout에 보인다.
  assign dout  = mem[rd_ptr];
  assign full  = (count == DEPTH);
  assign empty = (count == 5'd0);
endmodule

module tb;
  reg        clock = 0;
  reg        we = 0, reset = 1, push = 0, pop = 0;
  reg  [1:0] waddr = 0, raddr = 0;
  reg  [7:0] wdata = 0, din = 0;
  wire [7:0] rdata_async, rdata_sync, dout;
  wire       full, empty;
  wire [4:0] count;
  integer    c = 0;

  regfile rf (.clock(clock), .we(we), .waddr(waddr), .wdata(wdata), .raddr(raddr),
              .rdata_async(rdata_async), .rdata_sync(rdata_sync));
  sync_fifo #(.WIDTH(8), .DEPTH(4)) fifo (.clock(clock), .reset(reset), .push(push),
              .din(din), .pop(pop), .dout(dout), .full(full), .empty(empty), .count(count));

  always #5 clock = ~clock;

  // 하강 에지에서 한 사이클의 입력을 넣고, 그 사이클을 끝내는 상승 에지 전에 보이는 값을 출력한다.
  task rf_cycle(input w, input [1:0] wa, input [7:0] wd, input [1:0] ra);
    begin
      @(negedge clock);
      we = w; waddr = wa; wdata = wd; raddr = ra;
      #1 $display("RF   c=%0d we=%b waddr=%0d wdata=%h raddr=%0d | async=%h sync=%h",
                  c, we, waddr, wdata, raddr, rdata_async, rdata_sync);
      c = c + 1;
    end
  endtask

  task fifo_cycle(input p, input [7:0] d, input q);
    begin
      @(negedge clock);
      push = p; din = d; pop = q;
      #1 $display("FIFO c=%0d push=%b din=%h pop=%b | count=%0d full=%b empty=%b dout=%h",
                  c, push, din, pop, count, full, empty, dout);
      c = c + 1;
    end
  endtask

  initial begin
    $dumpfile("dump.vcd");
    $dumpvars(0, tb);
    rf_cycle(1, 0, 8'h11, 0);
    rf_cycle(1, 1, 8'h22, 0);
    rf_cycle(0, 0, 8'h00, 1);
    rf_cycle(0, 0, 8'h00, 1);
    // 지금까지 FIFO는 리셋 상태였다. 리셋을 풀고 사이클을 0부터 다시 센다.
    @(negedge clock) reset = 0;
    c = 0;
    fifo_cycle(1, 8'ha1, 0);
    fifo_cycle(1, 8'ha2, 0);
    fifo_cycle(1, 8'ha3, 0);
    fifo_cycle(1, 8'ha4, 0);
    fifo_cycle(1, 8'ha5, 0);
    fifo_cycle(1, 8'ha6, 1);
    fifo_cycle(1, 8'hb1, 1);
    fifo_cycle(0, 8'h00, 1);
    fifo_cycle(0, 8'h00, 1);
    fifo_cycle(0, 8'h00, 1);
    fifo_cycle(0, 8'h00, 1);
    fifo_cycle(0, 8'h00, 0);
    $finish;
  end
endmodule