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

3G开发

开发平台:

Others

  1. // The MIT License
  2. //
  3. // Copyright (c) 2006 Nirav Dave (ndave@csail.mit.edu)
  4. //
  5. // Permission is hereby granted, free of charge, to any person obtaining a copy
  6. // of this software and associated documentation files (the "Software"), to deal
  7. // in the Software without restriction, including without limitation the rights
  8. // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  9. // copies of the Software, and to permit persons to whom the Software is
  10. // furnished to do so, subject to the following conditions:
  11. //
  12. // The above copyright notice and this permission notice shall be included in
  13. // all copies or substantial portions of the Software.
  14. //
  15. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16. // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17. // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18. // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19. // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20. // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  21. // THE SOFTWARE.
  22. //////////////////////////////////////////////////////////////////////////////////
  23. // Copyright (c) 2006 Nirav Dave (ndave@csail.mit.edu)
  24. // Permission is hereby granted, free of charge, to any person obtaining
  25. // a copy of this software and associated documentation files (the
  26. // "Software"), to deal in the Software without restriction, including
  27. // without limitation the rights to use, copy, modify, merge, publish,
  28. // distribute, sublicense, and/or sell copies of the Software, and to
  29. // permit persons to whom the Software is furnished to do so, subject to
  30. // the following conditions:
  31. // The above copyright notice and this permission notice shall be
  32. // included in all copies or substantial portions of the Software.
  33. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  34. // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  35. // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  36. // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  37. // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  38. // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  39. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  40. //////////////////////////////////////////////////////////////////////////////////
  41. import FIFO::*;
  42. import FIFOF::*;
  43. import Vector::*;
  44. interface Pipeline#(type alpha);
  45.   method Action put(alpha x);
  46.   method ActionValue#(alpha) get();
  47. endinterface
  48. function alpha repeatFN(Bit#(b) reps, function alpha f(Bit#(b) stage, alpha fx), Bit#(b) stage, alpha in);
  49.   alpha new_in = f(stage, in);
  50.   return (reps == 0) ? in : repeatFN(reps - 1, f, stage+1, new_in);
  51. endfunction
  52. module mkPipeline_Circ#(Bit#(b) numstages,
  53.                         Bit#(b) step,
  54.                         function alpha sf(Bit#(b) s, alpha x))
  55.        (Pipeline#(alpha))
  56.     provisos
  57.        (Bits#(alpha, asz));
  58.      
  59.   // input queue
  60.   FIFOF#(alpha)       inputQ <- mkLFIFOF();
  61.   
  62.   // internal state
  63.   Reg#(Bit#(b))          stage <- mkReg(0);
  64.   Reg#(alpha)             s <- mkRegU;  
  65.   
  66.   // output queue
  67.   FIFO#(alpha)        outputQ <- mkLFIFO();
  68.   
  69.   rule compute(True);
  70.    // get input (implicitly stalls if no input)
  71.    alpha s_in = s; // default is from register
  72.    if (stage == 0)
  73.      begin    
  74.        s_in = inputQ.first();
  75.        inputQ.deq();
  76.      end
  77.    //do stage
  78.    let s_out = repeatFN(step, sf, stage, s_in);
  79.    // store output
  80.    stage <= (stage + step == numstages) ? 0 : stage + step;
  81.    if(stage + step == numstages)
  82.      outputQ.enq(s_out);
  83.    else
  84.      s <= s_out;
  85.   endrule 
  86.   
  87.   // The Interface
  88.   
  89.   method Action put(alpha x);
  90.     inputQ.enq(x);   
  91.   endmethod
  92.   
  93.   method ActionValue#(alpha) get();
  94.     outputQ.deq();
  95.     return outputQ.first();
  96.   endmethod
  97.   
  98. endmodule
  99. module mkPipeline_Sync#(Bit#(b) numstages,
  100.                         Bit#(b) step,
  101.                         function alpha sf(Bit#(b) s, alpha x))
  102.        (Pipeline#(alpha))
  103.     provisos
  104.        (Bits#(alpha, asz),Add#(b,k,32));
  105.   // input queue
  106.   FIFOF#(alpha)       inputQ <- mkLFIFOF();
  107.   
  108.   // internal state
  109.   // This is an over estimate of the space we need
  110.   // we're artificially restricted because there is no
  111.   // "reasonable way to pass a "static" parameter.
  112.   // We will only create/initialize the used registers though.
  113.   Vector#(TExp#(b), Reg#(Maybe#(alpha))) piperegs = newVector();
  114.   for(Bit#(b) i = 0; i < numstages; i = i + step)
  115.    begin
  116.      let pipereg <- mkReg(Nothing);
  117.      piperegs[i] = pipereg;
  118.    end
  119.   // output queue
  120.   FIFO#(alpha)        outputQ <- mkLFIFO();
  121.   
  122.   rule compute(True);
  123.     for(Bit#(b) stage = 0; stage < numstages; stage = stage + step)
  124.       begin
  125.         //Determine Inputs
  126.         Maybe#(alpha) in = Nothing; // Default Value Is Nothing
  127.   
  128.         if (stage != 0)                         // Not-First Stage takes from reg
  129.            in = (piperegs[stage - step])._read;
  130.         else if(inputQ.notEmpty) // take from queue at stage 0
  131.           begin    
  132.             in = Just(inputQ.first());
  133.             inputQ.deq();
  134.   end
  135.         alpha s_in = fromMaybe(?,in);
  136.   
  137.         //do stage
  138.   
  139.         alpha s_out = repeatFN(step, sf, stage, s_in);
  140. //deal with outputs
  141.         if (stage + step < numstages) // it's not the last stage
  142.           (piperegs[stage]) <= isJust(in) ? Just(s_out): Nothing;
  143.         else if(isValid(in)) // && stage == 2
  144.           outputQ.enq(s_out);
  145. else
  146.   noAction;
  147.         end     
  148.   endrule
  149.    
  150.   // The Interface
  151.   method Action put(alpha x);
  152.     inputQ.enq(x);   
  153.   endmethod
  154.   
  155.   method ActionValue#(alpha) get();
  156.     outputQ.deq();
  157.     return outputQ.first();
  158.   endmethod
  159.   
  160. endmodule
  161.      
  162.      
  163. module mkPipeline_Comb#(Bit#(b) numstages,
  164.                         Bit#(b) step,
  165.                         function alpha sf(Bit#(b) s, alpha x))
  166.        (Pipeline#(alpha))
  167.     provisos
  168.        (Bits#(alpha, asz));
  169.   // input queue
  170.   FIFOF#(alpha)       inputQ <- mkLFIFOF();
  171.   
  172.   // output queue
  173.   FIFO#(alpha)        outputQ <- mkLFIFO();
  174.   
  175.   rule compute(True);
  176.     alpha  stage_in, stage_out;
  177.     stage_in = inputQ.first();
  178.     inputQ.deq();
  179.      
  180.     for(Bit#(b) stage = 0; stage < numstages; stage = stage + step)
  181.       begin
  182.         //do stage
  183.         stage_out = repeatFN(step, sf, stage, stage_in);
  184.         //deal with outputs
  185.         stage_in = stage_out;
  186.       end     
  187.     outputQ.enq(stage_out);
  188.   endrule  
  189.    
  190.   // The Interface
  191.   method Action put(alpha x);
  192.     inputQ.enq(x);   
  193.   endmethod
  194.   
  195.   method ActionValue#(alpha) get();
  196.     outputQ.deq();
  197.     return outputQ.first();
  198.   endmethod
  199.   
  200. endmodule      
  201.      
  202.      
  203.      
  204.      
  205.      
  206.      
  207.      
  208.      
  209.      
  210.      
  211.      
  212.      
  213.      
  214.      
  215.      
  216.      
  217.      
  218.      
  219.      
  220.      
  221.      
  222.      
  223.      
  224.      
  225.      
  226.      
  227.      
  228.      
  229.      
  230.      
  231.      
  232.      
  233.      
  234.      
  235.      
  236.      
  237.      
  238.      
  239.      
  240.      
  241.      
  242.      
  243.      
  244.      
  245.      
  246.      
  247.      
  248.      
  249.      
  250.      
  251.      
  252.      
  253.      
  254.      
  255.      
  256.      
  257.      
  258.      
  259.      
  260.      
  261.      
  262.      
  263.      
  264.      
  265.