Subversion Repositories cryptosorter

// import standard librarys
import Connectable::*;
import GetPut::*;
import FIFO::*;
import StmtFSM::*;
import Vector::*;

// import self-made library
import BRAMVLevelFIFO::*;
import VLevelFIFO::*;
import Sort::*;
import LFSR::*;
import Memocode08Types::*;
import SortTree16::*;
import SortTree64::*;


typedef 16 KMerges;

typedef enum{
  Uninitialized,
  Burst,
  Idle,
  FIFOStage,
  FIFOIdle,
  Done
} State deriving (Bits,Eq);

module mkSortTreeTestbench(Empty);

   Vector#(KMerges,FIFO#(Record)) resultFIFOs <- replicateM(mkSizedFIFO(valueof(KMerges)+1)); 

//  SortTree#(KMerges,1,Bit#(7),Bit#(1),Maybe#(Bit#(128))) sortTree <- mkBRAMSort16; 
   let sortTree <- mkSortTree16; 
 
   Reg#(Bit#(TLog#(KMerges))) slabCount <- mkReg(0); 
   
   Reg#(Bit#(TMul#(2,TLog#(KMerges)))) finalCount <- mkReg(0);  
   
   Reg#(State) stateMeta <- mkReg(Burst);
   
   Reg#(Bit#(128)) lastValue <- mkReg(0);
   
   Reg#(Bit#(64)) cycleCnt <- mkReg(0);

   Reg#(Bit#(TLog#(TAdd#(KMerges,1)))) recvCount <- mkReg(0);

   Reg#(Bit#(TLog#(TAdd#(KMerges,1)))) sendCount <- mkReg(0);

   Reg#(Bit#(8)) nextValue <- mkReg(0);
   
   rule incrCycle (True);
      cycleCnt <= cycleCnt + 1;
      
      $display("cycle %d",cycleCnt);
   endrule
   
   rule getTokInfo (True);
      let tokInfo = sortTree.inStream.getTokInfo();
      
      for (Integer i = 0; i < valueOf(KMerges); i = i + 1)
         $display("Instream Tok Info idx %d tok %d",i,tokInfo[i]);
      
   endrule

  for(Integer i = 0; i < valueof(KMerges); i = i + 1) 
    begin 
      Reg#(Bool) initialized <- mkReg(False); 
      Reg#(Bit#(TLog#(KMerges))) count <- mkReg(0);       
      Reg#(State) state <- mkReg(Burst); 

      rule push ((state == Burst) && ((sortTree.inStream.getTokInfo())[i] > 1));
        $display("Sender %d is Bursting", i);
        sortTree.inStream.putDeqTok(fromInteger(i),2);
        sortTree.inStream.putRecord(fromInteger(i),
                                    tagged Valid (zeroExtend(nextValue)));
        nextValue <= nextValue + 101; // 101 is rel. prime to 256, and so will generate the U256 group
        state <= Idle;
      endrule

//      rule endpush ((state == Idle) && ((sortTree.inStream.getTokInfo())[i] > 0));
      rule endpush (state == Idle);
        $display("Sender %d is Idling", i);
        sortTree.inStream.putRecord(fromInteger(i), tagged Invalid);
        count <= count + 1;
        if(count + 1 == 0)
          begin
             state <= FIFOStage;
             sendCount <= sendCount + 1;
          end 
        else
          begin
            state <= Burst;
          end            
      endrule

      rule fifopush ((sendCount == 16) && (state == FIFOStage) && ((sortTree.inStream.getTokInfo())[i] > 0));
        $display("Sender %d is FIFOStage",i);
        sortTree.inStream.putDeqTok(fromInteger(i),1);
        resultFIFOs[i].deq;
        sortTree.inStream.putRecord(fromInteger(i), tagged Valid resultFIFOs[i].first);
        count <= count + 1;
        if(count + 1 == 0)
          begin
             state <= FIFOIdle;
          end 
        else
          begin
            state <= FIFOStage;
          end 
      endrule

      rule endfifo ((state == FIFOIdle)&& ((sortTree.inStream.getTokInfo())[i] > 0));
        $display("Sender %d is FIFOIdle",i);
        sortTree.inStream.putDeqTok(fromInteger(i),1);
        sortTree.inStream.putRecord(fromInteger(i), tagged Invalid);
        state <= Done;
      endrule      
    end
 

  rule readOutResults(stateMeta == Burst);
    let outdata <- sortTree.getRecord();    
    if(outdata matches tagged Valid .data)
      begin
         $display("Getting a slab result %d, recv count %d",data,recvCount);
         resultFIFOs[slabCount].enq(data);
         recvCount <= recvCount + 1;
         if(lastValue > data)
            begin
               $display("%m Error: %d > %d at %d", lastValue, data, finalCount);
               $finish();
            end
         lastValue <= data;
      end
    else
      begin 
        $display("Getting a end of stream token %d",recvCount);
         slabCount <= slabCount + 1;
         lastValue <= 0;
         recvCount <= 0;
         if (recvCount != fromInteger(valueOf(KMerges)))
            begin
               $display("error merge recv token too early %d", recvCount);
               $finish();
            end
         
         if(slabCount + 1 == 0)
            begin
               stateMeta <= FIFOStage;
            end
      end
  endrule

 
  rule readOutResultsFinal(stateMeta == FIFOStage);   
    $display("%m Getting a result");
    let outdata <- sortTree.getRecord();    
    if(outdata matches tagged Valid .data)
      begin
        finalCount <= finalCount + 1;
        if(zeroExtend(finalCount) != data)
          begin
             $display("%m Error: %d != %d at %d", finalCount, data, finalCount);
             $finish();
          end
        if(lastValue > data)
          begin
             $display("%m Error: %d > %d at %d", lastValue, data, finalCount);
             $finish();
          end
        lastValue <= data;
      end
    else
      begin
        if(finalCount != 0)
          begin
             $display("%m Error: final Value: %d", finalCount);
             $finish();
          end
        else
          begin 
            let timeVal <- $time();
            $display("%m PASSES at %d cycle %d", timeVal,cycleCnt); 
            $finish(); 
          end
      end
  endrule


endmodule