Traceback.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 FIFO::*;
  27. import Vector::*;
  28. import VParams::*;
  29. import ShiftRegs::*;
  30. import Parameters::*;
  31. //This is a pipelined implementation of the traceback logic
  32. //Parameters:
  33. //              L = Traceback length
  34. //    NoOfDecodes = # of decodes in 1 cycle
  35. // PipelineStages = # of pipeline stages = L/NoOfDecodes
  36. typedef TBLength                L;
  37. typedef TDiv#(L,NoOfDecodes)    PipelineStages;
  38. typedef TAdd#(NoOfDecodes,1)    CSRSize;
  39. typedef 24                      FIFOSize;
  40. typedef TSub#(KSz,1)            StateSize;
  41. typedef TExp#(StateSize)        NoOfStates;
  42. // interface
  43. interface Traceback;
  44.     method Action updateMemory(Vector#(NoOfStates, Bit#(1)) newPointers, Bit#(StateSize) minIndex);
  45.     method ActionValue#(Bit#(1)) getDecodedOutput();
  46.     method Action clear();
  47. endinterface
  48. (* noinline *)
  49. //Decode 1 column
  50. function Bit#(StateSize) decodeCol(Bit#(StateSize) currIndex, Vector#(NoOfStates,Bit#(1)) traceColumn);
  51.     return truncate({currIndex, traceColumn[currIndex]});
  52. endfunction
  53. (* noinline *)
  54. //Decode NoOfDecodes columns
  55. function Bit#(StateSize) decode(Bit#(StateSize) currIndex, Vector#(NoOfDecodes, Vector#(NoOfStates,Bit#(1))) traceColumns);
  56.     return foldl(decodeCol, currIndex, traceColumns);
  57. endfunction
  58. interface TracebackMemory;
  59.     method Action addColumn(Vector#(NoOfStates, Bit#(1)) newPointers);
  60.     method Vector#(PipelineStages, Vector#(CSRSize, Vector#(NoOfStates, Bit#(1)))) getAllMem();
  61.     method Action clear();
  62. endinterface
  63. (* synthesize *)
  64. module mkCSRforTB(ShiftRegs#(CSRSize, Vector#(NoOfStates, Bit#(1))));
  65.    ShiftRegs#(CSRSize, Vector#(NoOfStates, Bit#(1))) memory <- mkCirShiftRegs;
  66.    return memory;
  67. endmodule // mkCSRforTB
  68.    
  69. (* synthesize *)
  70. module mkTracebackMemory(TracebackMemory);
  71.     //Traceback memory:
  72.     //There are PipelineStages number of Circular Shift Registers (CSR)
  73.     //Each cycle, a new column of Vector#(64, Bit#(1)) is added to the leftmost CSR
  74.     //and the rightmost column of each CSR is added to the next CSR
  75.     Vector#(PipelineStages, ShiftRegs#(CSRSize, Vector#(NoOfStates, Bit#(1)))) tracebackMemory <- replicateM(mkCSRforTB);
  76.     
  77.     method Action addColumn(Vector#(NoOfStates, Bit#(1)) newPointers);
  78.         tracebackMemory[0].enq(newPointers);
  79.         for(Integer i = 0; i < valueOf(PipelineStages)-1; i=i+1)
  80.             tracebackMemory[i+1].enq(tracebackMemory[i].first());
  81.     endmethod
  82.     method Vector#(PipelineStages, Vector#(CSRSize, Vector#(NoOfStates, Bit#(1)))) getAllMem();
  83.         Vector#(PipelineStages, Vector#(CSRSize, Vector#(NoOfStates, Bit#(1)))) allMem = newVector();
  84.         for(Integer i = 0; i < valueOf(PipelineStages); i=i+1)
  85.             allMem[i] = tracebackMemory[i].getVector();
  86.         return allMem;
  87.     endmethod
  88.     method Action clear();
  89.         for(Integer i = 0; i < valueOf(PipelineStages); i=i+1)
  90.         begin
  91.             tracebackMemory[i].clear();
  92.         end
  93.     endmethod
  94. endmodule
  95. (* synthesize *)
  96. module mkTraceback(Traceback);
  97.     TracebackMemory                                     tracebackMemory <- mkTracebackMemory();
  98.     Vector#(PipelineStages, Reg#(Maybe#(Bit#(StateSize)))) minStateRegs <- replicateM(mkReg(tagged Invalid));
  99.     Reg#(UInt#(TLog#(TAdd#(L,1))))                                       counter <- mkReg(0);
  100.     FIFO#(Bit#(1))                                             outQueue <- mkSizedFIFO(valueOf(FIFOSize));
  101.     Vector#(PipelineStages, Vector#(CSRSize, Vector#(NoOfStates, Bit#(1))))           allMem = tracebackMemory.getAllMem();
  102.     Vector#(PipelineStages, Vector#(NoOfDecodes, Vector#(NoOfStates, Bit#(1)))) tracebackMem = newVector();
  103.     for(Integer i = 0; i < valueOf(PipelineStages); i=i+1)
  104.     begin
  105.         tracebackMem[i] = newVector();
  106.         for(Integer j = 0; j < valueOf(NoOfDecodes); j=j+1)
  107.             tracebackMem[i][j] = allMem[i][valueOf(NoOfDecodes)-j];
  108.     end
  109.     method Action updateMemory(Vector#(NoOfStates, Bit#(1)) newPointers, Bit#(StateSize) minIndex);
  110.         tracebackMemory.addColumn(newPointers);
  111.         //$write("%t: ", $stime);
  112.         //for(Integer i = 0; i < valueOf(NoOfStates); i=i+1)
  113.             //$write("%b", newPointers[i]);
  114.         //$write(" %bn", minIndex);
  115.         if(counter == fromInteger(valueOf(L)))
  116.             (minStateRegs[0]) <= tagged Valid minIndex;
  117.         else          counter <= counter+1;
  118.         let lastStage = valueOf(PipelineStages)-1;
  119.         for(Integer i = 0; i < lastStage; i=i+1)
  120.         begin
  121.             if(isValid(minStateRegs[i]._read()))
  122.             begin
  123.                 let decColumns       = tracebackMem[i];
  124.                 let newIndex         = decode(fromMaybe(0,minStateRegs[i]._read()), decColumns);
  125.                 (minStateRegs[i+1])  <= tagged Valid newIndex;
  126.             end
  127.             else (minStateRegs[i+1]) <= tagged Invalid;
  128.         end
  129.         if(isValid(minStateRegs[lastStage]._read()))
  130.         begin
  131.             let decLastColumns = tracebackMem[lastStage];
  132.             let minState = decode(fromMaybe(0,minStateRegs[lastStage]._read()), decLastColumns);
  133.             //$write("%t: ", $stime);
  134.             //$write("%bn", minState);
  135.             outQueue.enq(tpl_1(split(minState)));
  136.         end
  137.     endmethod 
  138.     method ActionValue#(Bit#(1)) getDecodedOutput();
  139.         outQueue.deq();
  140.         return outQueue.first();
  141.     endmethod
  142.     method Action clear();
  143.         tracebackMemory.clear();
  144.         for(Integer i = 0; i < valueOf(PipelineStages); i=i+1)
  145.             (minStateRegs[i]) <= tagged Invalid;
  146.         counter <= 0;
  147.         outQueue.clear();
  148.     endmethod
  149. endmodule