Pipeline2.bsv
上传用户:aoptech
上传日期:2014-09-22
资源大小:784k
文件大小:7k
源码类别:

3G开发

开发平台:

Others

  1. //----------------------------------------------------------------------//
  2. // The MIT License 
  3. // 
  4. // Copyright (c) 2007 Alfred Man Cheuk Ng, mcn02@mit.edu 
  5. // 
  6. // Permission is hereby granted, free of charge, to any person 
  7. // obtaining a copy of this software and associated documentation 
  8. // files (the "Software"), to deal in the Software without 
  9. // restriction, including without limitation the rights to use,
  10. // copy, modify, merge, publish, distribute, sublicense, and/or sell
  11. // copies of the Software, and to permit persons to whom the
  12. // Software is furnished to do so, subject to the following conditions:
  13. // 
  14. // The above copyright notice and this permission notice shall be
  15. // included in all copies or substantial portions of the Software.
  16. // 
  17. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18. // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  19. // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  20. // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  21. // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  22. // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  23. // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  24. // OTHER DEALINGS IN THE SOFTWARE.
  25. //----------------------------------------------------------------------//
  26. import Connectable::*;
  27. import FIFO::*;
  28. import GetPut::*;
  29. import List::*;
  30. import RWire::*;
  31. import Vector::*;
  32. import EHRReg::*;
  33. interface Pipeline2#(type a);
  34.   interface Put#(a) in;
  35.   interface Get#(a) out;
  36. endinterface
  37.   
  38. // bypass pipestage with rwire, need to guarantee get can always fire
  39. module mkPipeStage_RWire#(function a f(a mesg))
  40.     (Pipeline2#(a)) provisos (Bits#(a,asz));
  41.       RWire#(a) canGet <- mkRWire;
  42.       interface Put in;
  43.  method Action put(a mesg);
  44.     canGet.wset(f(mesg));
  45.  endmethod
  46.       endinterface
  47.   
  48.       interface Get out;
  49.  method ActionValue#(a) get() if (isValid(canGet.wget));
  50.             return fromMaybe(?, canGet.wget);
  51.  endmethod
  52.       endinterface           
  53. endmodule
  54. // normal pipeStage with FIFO
  55. module mkPipeStage_FIFO#(function a f(a mesg))
  56.     (Pipeline2#(a)) provisos (Bits#(a,asz));
  57.       FIFO#(a) outQ <- mkSizedFIFO(2);
  58.       interface Put in;
  59.  method Action put(a mesg);
  60.     outQ.enq(f(mesg));
  61.  endmethod
  62.       endinterface
  63.   
  64.       interface out = fifoToGet(outQ);
  65. endmodule
  66. // normal pipeline
  67. module [Module] mkPipeline2_Norm#(Bit#(idx_sz) maxStage,
  68.  function Module#(Pipeline2#(a)) mkP)
  69.   (Pipeline2#(a)) provisos (Bits#(a, asz));
  70.    // state elements
  71.    Vector#(TExp#(idx_sz), Pipeline2#(a)) stageFUs = newVector;
  72.    FIFO#(a) outQ <- mkSizedFIFO(2);
  73.    stageFUs[0] <- mkP;
  74.    for (Bit#(idx_sz) i = 1; i <= maxStage; i = i + 1)
  75.      begin
  76. stageFUs[i] <- mkP;
  77. mkConnection(stageFUs[i-1].out, stageFUs[i].in);
  78.      end
  79.    mkConnection(stageFUs[maxStage].out, fifoToPut(outQ));
  80.    
  81.    // methods
  82.    interface in = stageFUs[0].in;
  83.    interface out = fifoToGet(outQ);   
  84. endmodule // mkP
  85. // circular pipeline, assume stageFU.out < stageFU.in or no conflict   
  86. module [Module] mkPipeline2_Circ#(Bit#(idx_sz) maxStage,
  87.  function Module#(Pipeline2#(a)) mkP)
  88.   (Pipeline2#(a)) provisos (Bits#(a, asz));
  89.    
  90.    // instantiate sharable functional unit
  91.    FIFO#(a) outQ <- mkSizedFIFO(2);
  92.    Pipeline2#(a) stageFU <- mkP;
  93.    EHRReg#(2,Maybe#(Bit#(idx_sz))) stage <- mkEHRReg(Invalid);
  94.    RWire#(a) passData <- mkRWire;
  95.    
  96.    // constants
  97.    Reg#(Maybe#(Bit#(idx_sz))) stage0 = (stage[0]);
  98.    Reg#(Maybe#(Bit#(idx_sz))) stage1 = (stage[1]);
  99.    rule getStageRes(isValid(stage0));
  100.       let curStage = fromMaybe(?,stage0);
  101.       let res <- stageFU.out.get;
  102.       if (curStage == maxStage) // finish
  103.  begin
  104.     outQ.enq(res);
  105.     stage0 <= tagged Invalid;
  106.  end
  107.       else
  108.  begin
  109.     passData.wset(res);
  110.     stage0 <= tagged Valid (curStage + 1);
  111.  end
  112. //      $display("circ.getStageRes: stage: %d",curStage);
  113.    endrule
  114.    rule execNextStage(isValid(stage1) && isValid(passData.wget));
  115.       let mesg = fromMaybe(?,passData.wget);
  116.       stageFU.in.put(mesg);
  117. //      $display("cir.execNextStage");
  118.    endrule
  119.    
  120. //     rule printCheck(True);
  121. //        $display("maxStage =  %d",maxStage);
  122. //        $display("isValid(stage[0]) = %d",isValid(stage0));
  123. //        $display("stage[0] = %d",fromMaybe(?,stage0));
  124. //        $display("isValid(stage[1]) = %d",isValid(stage1));
  125. //        $display("stage[1] = %d",fromMaybe(?,stage1));
  126. //        $display("isValid(passData.wget) = %d",isValid(passData.wget));
  127. //  //      $display("passData.wget = %d",fromMaybe(?,passData.wget));
  128. //     endrule
  129.     
  130.    interface Put in;
  131.       method Action put(a mesg) if (!isValid(stage1));
  132.  stageFU.in.put(mesg);
  133.          stage1 <= tagged Valid 0;
  134.       endmethod
  135.    endinterface
  136.    
  137.    interface out = fifoToGet(outQ);
  138. endmodule // mkP
  139. // time multiplex pipline
  140. module [Module] mkPipeline2_Time#(function Module#(Pipeline2#(Vector#(psz,a))) mkP)
  141.   (Pipeline2#(Vector#(sz,a)))
  142.    provisos (Bits#(a, asz),
  143.      Div#(sz,psz,noStages), // div now change to return ceiling 
  144.      Log#(noStages,stage_idx),
  145.      Mul#(noStages,psz,total_sz),
  146.      Add#(sz,ext_sz,total_sz),
  147.      Bits#(Vector#(total_sz,a),xxA),
  148.      Bits#(Vector#(noStages,Vector#(psz,a)),xxA));
  149.    // constants
  150.    Integer maxStageInt = valueOf(noStages)-1;
  151.    Bit#(stage_idx) maxStage = fromInteger(maxStageInt);
  152.    Integer pSzInt = valueOf(psz);
  153.    
  154.    // state element
  155.    Pipeline2#(Vector#(psz,a)) stageFU <- mkP;
  156.    Reg#(Bit#(stage_idx)) putStage <- mkReg(0);
  157.    Reg#(Bit#(stage_idx)) getStage <- mkReg(0);
  158.    Vector#(noStages,FIFO#(Vector#(psz,a))) inBuffers = newVector;
  159.    for (Integer i = 1; i <= maxStageInt; i = i + 1)
  160.       inBuffers[i] <- mkLFIFO;
  161.    Vector#(noStages,FIFO#(Vector#(psz,a))) outBuffers = newVector;
  162.    outBuffers <- replicateM(mkLFIFO);
  163.    
  164.    rule startExec(putStage > 0);
  165.    begin
  166.       let mesg = inBuffers[putStage].first;
  167.       inBuffers[putStage].deq;
  168.       stageFU.in.put(mesg);
  169.       putStage <= (putStage == maxStage) ? 0 : putStage + 1;
  170. //      $display("time.startExec: putStage: %d",putStage);
  171.    end
  172.    endrule
  173.    rule finishExec(True);
  174.    begin
  175.       let mesg <- stageFU.out.get;
  176.       outBuffers[getStage].enq(mesg);
  177.       getStage <= (getStage == maxStage) ? 0 : getStage + 1;
  178. //      $display("time.finishExec: getStage: %d",getStage);
  179.    end
  180.    endrule
  181.    interface Put in;
  182.       method Action put(Vector#(sz,a) mesg) if (putStage == 0);
  183.  Vector#(ext_sz, a) extVec = newVector;
  184.  Vector#(total_sz, a) appendVec = append(mesg, extVec);
  185.  Vector#(noStages, Vector#(psz, a)) resVecs = unpack(pack(appendVec));
  186.  for (Integer i = 1; i <= maxStageInt; i = i + 1)
  187.     inBuffers[i].enq(resVecs[i]);
  188.  stageFU.in.put(resVecs[0]);
  189.  putStage <= (maxStageInt == 0) ? 0 : 1;
  190.       endmethod
  191.    endinterface
  192.    interface Get out;
  193.       method ActionValue#(Vector#(sz,a)) get();
  194.  Vector#(noStages, Vector#(psz, a)) outVecs = newVector;
  195.  for (Integer i = 0; i <= maxStageInt; i = i + 1)
  196.    begin
  197.       outVecs[i] = outBuffers[i].first;
  198.       outBuffers[i].deq;
  199.    end  
  200.  Vector#(total_sz, a) appendVec = unpack(pack(outVecs));
  201.          return take(appendVec);
  202.       endmethod
  203.    endinterface     
  204. endmodule // mkP