1. EHRs: Designing modules with concurrent methods
Arvind
Computer Science & Artificial Intelligence Lab.
Massachusetts Institute of Technology
February 17, 2016

2. Elastic pipeline f1 f2 f3 x
inQ
fifo1
fifo2
outQ
Whether these rules can fire concurrently depends crucially on the properties of fifo methods
rule stage1 if (True);
fifo1.enq(f1(inQ.first());
inQ.deq(); endrule
rule stage2 if (True);
fifo2.enq(f2(fifo1.first());
fifo1.deq(); endrule
rule stage3 if (True);
outQ.enq(f3(fifo2.first());
fifo2.deq(); endrule
February 17, 2016

3. Elastic pipeline Expressed as a single rulef0 f1 f2 x
inQ
fifo1
fifo2
outQ
rule elasticPipeline;
fifo1.enq(f0(inQ.first); inQ.deq;
fifo2.enq(f1(fifo1.first); fifo1.deq;
outQ.enq(f2(fifo2.first); fifo2.deq);
endrule
What is wrong?
February 17, 2016

4. Elastic pipeline Expressed as a single rule using guard lifting
inQ
fifo1
fifo2
outQ
rule elasticPipeline;
if(inQ.notEmpty && fifo1.notFull)
begin fifo1.enq(f0(inQ.first); inQ.deq end;
if(fifo1.notEmpty && fifo2.notFull)
begin fifo2.enq(f1(fifo1.first); fifo1.deq end;
if(fifo2.notEmpty && outQ.notFull)
begin outQ.enq(f2(fifo2.first); fifo2.deq) end;
endrule
All stages may be active simultaneously if an enq and deq on a FIFO can be performed simultaneously
February 17, 2016

5. Designing FIFOs
February 17, 2016

6. One-Element FIFO module mkCFFifo (Fifo#(1, t));
Reg#(t) d <- mkRegU;
Reg#(Bool) v <- mkReg(False);
method Action enq(t x) if (!v);
v <= True; d <= x;
endmethod
method Action deq if (v);
v <= False;
method t first if (v);
return (d);
endmodule
not empty
not full n
rdy
enab
enq
deq
module
Fifo
What if enq and deq were executed together?
Can enq and deq be ready simultaneously?
double write error
no!
February 17, 2016

7. Two-Element FIFO
db da
module mkCFFifo (Fifo#(2, t));
Reg#(t) da <- mkRegU();
Reg#(Bool) va <- mkReg(False);
Reg#(t) db <- mkRegU();
Reg#(Bool) vb <- mkReg(False);
method Action enq(t x) if (!vb);
if va then begin db <= x; vb <= True; end
else begin da <= x; va <= True; end
endmethod
method Action deq if (va);
if vb then begin da <= db; vb <= False; end
else begin va <= False; end
method t first if (va);
return da;
endmodule
Assume, if there is only one element in the FIFO it resides in da
enq and deq can be enabled simultaneously
but concurrent execution of enq and deq will cause double write errors
February 17, 2016

8. Single-rule version f1 f2 f3 x inQ fifo1 fifo2 outQ rule stage1;
if(inQ.notEmpty && fifo1.notFull)
begin fifo1.enq(f1(inQ.first); inQ.deq end;
if(fifo1.notEmpty && fifo2.notFull)
begin fifo2.enq(f2(fifo1.first); fifo1.deq end;
if(fifo2.notEmpty && outQ.notFull)
begin outQ.enq(f3(fifo2.first); fifo2.deq) end;
endrule
This rule is illegal if concurrent operations on FIFOs are not permitted
February 17, 2016

9. Limitations of registers
Limitations of a language with only the register primitive
No communication between rules or between methods or between rules and methods in the same atomic action i.e. clock cycle
Can’t express a FIFO with concurrent enq and deq
February 17, 2016

10. EHR: Ephemeral History Register
A new primitive element to design modules with concurrent methods
February 17, 2016

11. Ephemeral History Register (EHR) Dan Rosenband [MEMOCODE’04]Q 1
w[0].data
w[0].en
r[0]
normal
bypass
r[1]
w[1].data
w[1].en
r[1] returns:
– the current state if w[0] is not enabled
– the value being written (w[0].data) if w[0] is enabled
w[i+1] takes precedence over w[i]
r[0] < w[0]
r[1] < w[1]
w[0] < w[1] < ….
February 17, 2016

12. Designing FIFOs using EHRs
Conflict-Free FIFO: Both enq and deq are permitted concurrently as long as the FIFO is not-full and not-empty
The effect of enq is not visible to deq, and vise versa
Pipeline FIFO: An enq into a full FIFO is permitted provided a deq from the FIFO is done simultaneously
Bypass FIFO: A deq from an empty FIFO is permitted provided an enq into the FIFO is done simultaneously
February 17, 2016

13. One-Element Pipelined FIFO
module mkPipelineFifo(Fifo#(1, t)) provisos(Bits#(t, tSz));
Reg#(t) d <- mkRegU;
Ehr#(2, Bool) v <- mkEhr(False);
method Action enq(t x) if(!v[1]);
d <= x;
v[1] <= True;
endmethod
method Action deq if(v[0]);
v[0] <= False;
method t first if(v[0]);
return d;
endmodule
Desired behavior
deq < enq
first < deq
first < enq
No double write error
In any given cycle:
If the FIFO is not empty then simultaneous enq and deq are permitted;
Otherwise, only enq is permitted
Subtle problem if enq and deq calls are from the same rule.
February 17, 2016

14. One-Element Bypass FIFO using EHRs
module mkBypassFifo(Fifo#(1, t)) provisos(Bits#(t, tSz));
Ehr#(2, t) d <- mkEhr(?);
Ehr#(2, Bool) v <- mkEhr(False);
method Action enq(t x) if(!v[0]);
d[0] <= x;
v[0] <= True;
endmethod
method Action deq if(v[1]);
v[1] <= False;
method t first if(v[1]);
return d[1];
endmodule
Desired behavior
enq < deq
first < deq
enq < first
No double write error
In any given cycle:
If the FIFO is not full then simultaneous enq and deq are permitted;
Otherwise, only deq is permitted
February 17, 2016

15. Two-Element Conflict-free FIFO
db da
module mkCFFifo(Fifo#(2, t)) provisos(Bits#(t, tSz));
Ehr#(2, t) da <- mkEhr(?);
Ehr#(2, Bool) va <- mkEhr(False);
Ehr#(2, t) db <- mkEhr(?);
Ehr#(2, Bool) vb <- mkEhr(False);
rule canonicalize if(vb[1] && !va[1]);
da[1] <= db[1]; va[1] <= True;
vb[1] <= False; endrule
method Action enq(t x) if(!vb[0]);
db[0] <= x; vb[0] <= True; endmethod
method Action deq if (va[0]);
va[0] <= False; endmethod
method t first if(va[0]);
return da[0]; endmethod
endmodule
Assume, if there is only one element in the FIFO it resides in da
Desired behavior
enq CF deq
first < deq
first CF enq
In any given cycle:
Simultaneous enq and deq are permitted only if the FIFO is not full and not empty
February 17, 2016

16. Register File: normal and bypass
rdy en
rd1
rd2
Reg File wr
idx d
Normal rf: the effect of a register update can only be seen a cycle later, consequently, reads and writes are conflict-free
{rd1, rd2} < wr
Bypass rf: in case of concurrent reads and write, check if rd1==wr or rd2==wr then pass the new value as the result and update the register file, otherwise the old value in the rf is read
wr < {rd1, rd2}
February 17, 2016

17. Normal Register File d rd1 {rd1, rd2} < wr rdy Reg File wr en idx
module mkRFile(RFile);
Vector#(32,Reg#(Data)) rfile <- replicateM(mkReg(0));
method Action wr(Rindx rindx, Data d);
rfile[rindx] <= d;
endmethod
method Data rd1(Rindx rindx) = rfile[rindx];
method Data rd2(Rindx rindx) = rfile[rindx];
endmodule
February 17, 2016 17

18. Bypass Register File using EHR
rdy en
rd1
rd2
BpsReg File wr
idx d
wr < {rd1, rd2}
module mkBypassRFile(RFile);
Vector#(32,EHR#(2, Data)) rfile <-
replicateM(mkEHR(0));
method Action wr(Rindx rindx, Data d);
rfile[rindex][0] <= d;
endmethod
method Data rd1(Rindx rindx) = rfile[rindx][1];
method Data rd2(Rindx rindx) = rfile[rindx][1];
endmodule
February 17, 2016 18

19. Bypass Register File with external bypassing
{rf.rd1, rf.rd2} < rf.wr
rd1
rd2
Reg File wr
rdy
rd1
rd2
idx d
search
move
wr < {rd1, rd2}
rdy en wr
idx d
Bypass sFifo
February 17, 2016 19

20. Bypass Register File with external bypassing
module mkBypassRFile(BypassRFile);
RFile rf <- mkRFile;
Fifo#(1, Tuple2#(RIndx, Data))
bypass <- mkBypassSFifo;
rule move;
begin rf.wr(bypass.first); bypass.deq end;
endrule
method Action wr(RIndx rindx, Data d);
bypass.enq(tuple2(rindx, d));
endmethod
method Data rd1(RIndx rindx) =
return (!bypass.search1(rindx)) ? rf.rd1(rindx)
: bypass.read1(rindx);
method Data rd2(RIndx rindx) =
return (!bypass.search2(rindx)) ? rf.rd2(rindx)
: bypass.read2(rindx);
endmodule
{rf.rd1, rf.rd2} < rf.wr
wr < {rd1, rd2}
February 17, 2016 20

21. N-element Conflict-free FIFO
deqP
enqP
Checking for emptiness and fullness
Empty: enqP == deqP
Full: enqP == deqP + FIFO_size
To deal with the wrap around problem, assume enqP and deqP can contain indices for up to twice the size of the FIFO. Pointers are incremented modulo 2*n while buffer is accessed by pointer modulo n values
February 17, 2016

22. N-element Conflict-free FIFO
locks for preventing accesses until canonicalization
deqP
enqP
enqEn
deqEn
an enq updates enqP and puts the data into the array. It also sets enqEn to false to prevent further enqueues
a deq updates deqP and sets deqEn to false to prevent further dequeues
Canonicalize rule calculates the new count and sets the enqEn and deqEn bits appropriately
February 17, 2016

23. N-element Conflict-free FIFO methods
method Action enq(t x) if(enqEn[0]); enqP[0] <= (enqP[0] + 1)%n2; // n2 is 2*nb enqEn[0] <= False; d[enqP[0]%nb] <= x; endmethod method Action deq if(deqEn[0]); deqP[0] <= (deqP[0] + 1)%n2; deqEn[0] <= False; method t first if(deqEn[0]); return d[deqP[0]%nb]; endmodule
February 17, 2016

24. N-element Conflict-free FIFO: The canonicalization rule
rule canonicalize; let cnt = enqP[1] >= deqP[1]? enqP[1] - deqP[1]: (enqP[1]%nb + nb) - deqP[1]%nb; if(!enqEn[1] && cnt != nb) enqEn[1] <= True; if(!deqEn[1] && cnt != 0) deqEn[1] <= True; endrule
February 17, 2016

25. N-element Conflict-free FIFO: The canonicalization rule
rule canonicalize; Bit#(sz1) cnt = enqP[1] >= deqP[1]? enqP[1] - deqP[1]: (enqP[1]%nb + nb) - deqP[1]%nb; if(!enqEn[1] && cnt != nb) enqEn[1] <= True; if(!deqEn[1] && cnt != 0) deqEn[1] <= True; if(isValid(oldEnqP[1])) begin d[validValue(oldEnqP[1])] <= newData[1]; oldEnqP[1] <= Invalid; end endrule
February 17, 2016

26. N-element Conflict-free FIFO: state declarations
module mkCFFifo(Fifo#(n, t))
provisos(Bits#(t, tSz), Add#(n, 1, n1), Log#(n1, sz), Add#(sz, 1, sz1));
Integer ni = valueOf(n); Bit#(sz1) nb = fromInteger(ni);
Bit#(sz1) n2 = 2*nb;
Vector#(n, Reg#(t)) d <- replicateM(mkRegU);
Ehr#(2, Bit#(sz1)) enqP <- mkEhr(0);
Ehr#(2, Bit#(sz1)) deqP <- mkEhr(0);
Ehr#(2, Bool) enqEn <- mkEhr(True);
Ehr#(2, Bool) deqEn <- mkEhr(False);
Ehr#(2, t) newData <- mkEhr(?);
Ehr#(2, Maybe#(Bit#(sz1))) oldEnqP <- mkEhr(Invalid);
February 17, 2016

27. Extras
February 17, 2016

28. N-element searchable FIFO search CF {deq, enq}
Need a oldDeqP also to avoid scheduling constraints between deq and Search
module mkCFSFifo#(function Bool isFound(t v, st k))(SFifo#(n, t, st)) provisos(Bits#(t, tSz), Add#(n, 1, n1), Log#(n1, sz), Add#(sz, 1, sz1)); Integer ni = valueOf(n); Bit#(sz1) nb = fromInteger(ni); Bit#(sz1) n2 = 2*nb; Vector#(n, Reg#(t)) d <- replicateM(mkRegU); Ehr#(2, Bit#(sz1)) enqP <- mkEhr(0); Ehr#(2, Bit#(sz1)) deqP <- mkEhr(0); Ehr#(2, Bool) enqEn <- mkEhr(True); Ehr#(2, Bool) deqEn <- mkEhr(False); Ehr#(2, t) newData <- mkEhr(?); Ehr#(2, Maybe#(Bit#(sz1))) oldEnqP <- mkEhr(Invalid); Ehr#(2, Maybe#(Bit#(sz1))) oldDeqP <- mkEhr(Invalid);
February 17, 2016

29. N-element searchable FIFO search CF {deq, enq} continued-1
Bit#(sz1) cnt0 = enqP[0] >= deqP[0]? enqP[0] - deqP[0]: (enqP[0]%nb + nb) - deqP[0]%nb; Bit#(sz1) cnt1 = enqP[1] >= deqP[1]? enqP[1] - deqP[1]: (enqP[1]%nb + nb) - deqP[1]%nb; rule canonicalize; if(!enqEn[1] && cnt2 != nb) enqEn[1] <= True; if(!deqEn[1] && cnt2 != 0) deqEn[1] <= True; if(isValid(oldEnqP[1])) begin d[validValue(oldEnqP[1])] <= newData[1]; oldEnqP[1] <= Invalid; end if(isValid(oldDeqP[1])) begin deqP[0] <= validValue(oldDeqP[1]); oldDeqP[1]<=Invalid; endrule
February 17, 2016

30. N-element searchable FIFO search CF {deq, enq} continued-2
method Action enq(t x) if(enqEn[0]); newData[0] <= x; oldEnqP[0] <= Valid (enqP[0]%nb); enqP[0] <= (enqP[0] + 1)%n2; enqEn[0] <= False; endmethod method Action deq if(deqEn[0]); oldDeqP[0] <= Valid ((deqP[0] + 1)%n2); deqEn[0] <= False; method t first if(deqEn[0]); return d[deqP[0]%nb];
February 17, 2016

31. N-element searchable FIFO search CF {deq, enq} continued-3
method Bool search(st s); Bool ret = False; for(Bit#(sz1) i = 0; i < nb; i = i + 1) begin let ptr = (deqP[0] + i)%nb; if(isFound(d[ptr], s) && i < cnt0) ret = True; end return ret; endmethod endmodule
February 17, 2016

32. N-element searchable FIFO deq < search, deq < enq
This will make a good lab assignment
module mkPipelineSFifo#(function Bool isFound(t v, st k))(SFifo#(n, t, st)) provisos(Bits#(t, tSz), Add#(n, 1, n1), Log#(n1, sz), Add#(sz, 1, sz1), Bits#(st, stz)); Integer ni = valueOf(n); Bit#(sz1) nb = fromInteger(ni); Bit#(sz1) n2 = 2*nb; Vector#(n, Reg#(t)) d <- replicateM(mkRegU); Ehr#(2, Bit#(sz1)) enqP <- mkEhr(0); Ehr#(2, Bit#(sz1)) deqP <- mkEhr(0);
February 17, 2016

33. N-element searchable FIFO deq < search, deq < enq
Bit#(sz1) cnt0 = enqP[0] >= deqP[0]? enqP[0] - deqP[0]: (enqP[0]%nb + nb) - deqP[0]%nb; Bit#(sz1) cnt1 = enqP[0] >= deqP[1]? enqP[0] - deqP[1]: (enqP[0]%nb + nb) - deqP[1]%nb; method Action enq(t x) if(cnt1 < nb); enqP[0] <= (enqP[0] + 1)%n2; d[enqP[0]%nb] <= x; endmethod method Action deq if(cnt0 != 0); deqP[0] <= (deqP[0] + 1)%n2; method t first if(cnt0 != 0); return d[deqP[0]%nb];
February 17, 2016

34. N-element searchable FIFO deq < search, deq < enq
method Bool search(st s); Bool ret = False; for(Bit#(sz1) i = 0; i < nb; i = i + 1) begin let ptr = (deqP[1] + i)%nb; if(isFound(d[ptr], s) && i < cnt1) ret = True; end return ret; endmethod endmodule
February 17, 2016