def command_pipeline_convert(): reset = Signal(bool(0)) clk = Signal(bool(0)) LEN_THETA=3 NB_PIPELINE_STAGES = 5 DATAWIDTH=32 CHANNEL_WIDTH=1 INIT_DATA=0 #(0 for intbv) # --- Pipeline Pars pars=OperandPipelinePars() pars.NB_PIPELINE_STAGES=NB_PIPELINE_STAGES pars.DATAWIDTH=DATAWIDTH pars.CHANNEL_WIDTH=CHANNEL_WIDTH pars.INIT_DATA=INIT_DATA pars.LEN_THETA=LEN_THETA # --- Initializing Pipeline A pipe_inpA = PipelineST(pars.DATAWIDTH,pars.CHANNEL_WIDTH,pars.INIT_DATA) # --- Initializing Pipeline B pipe_inpB = PipelineST(pars.DATAWIDTH,pars.CHANNEL_WIDTH,pars.INIT_DATA) # --- Initializing Activation Out pipe_out_activ = PipelineST(pars.DATAWIDTH,pars.CHANNEL_WIDTH,pars.INIT_DATA) toVerilog(lr_top, pars, reset, clk, pipe_inpA, pipe_inpB, pipe_out_activ) toVHDL(lr_top, pars, reset, clk, pipe_inpA, pipe_inpB, pipe_out_activ)
def __init__(self): """ Initialize CommandPipeline Ios """ self.NB_PIPELINE_STAGES = 4 self.DATAWIDTH = 32 self.CHANNEL_WIDTH = 1 self.INIT_DATA = 0 self.stage_o = [PipelineST(self.DATAWIDTH,self.CHANNEL_WIDTH,self.INIT_DATA) for i in range(self.NB_PIPELINE_STAGES)]
def __init__( self , DATAWIDTH = 32, CHANNEL_WIDTH = 1, INIT_DATA = 0): self.DATAWIDTH = DATAWIDTH self.CHANNEL_WIDTH = CHANNEL_WIDTH self.INIT_DATA = INIT_DATA # Io Signals self.pipeST_i = PipelineST ( self.DATAWIDTH, self.CHANNEL_WIDTH, self.INIT_DATA ) self.pipeST_o = PipelineST ( self.DATAWIDTH, self.CHANNEL_WIDTH, self.INIT_DATA ) # Internal Signals self.classifier = PipelineST ( self.DATAWIDTH, self.CHANNEL_WIDTH, self.INIT_DATA ) # Reset value to incorporate float and intbv formats self.zero = 0.0 if ( isinstance ( self.INIT_DATA, float ) ) else 0 self.one = 1.0 if ( isinstance ( self.INIT_DATA, float ) ) else 1
def __init__( self , DATAWIDTH = 32, CHANNEL_WIDTH = 1, INIT_DATA = 0, NB_ACCUMULATIONS = 3): self.DATAWIDTH = DATAWIDTH self.CHANNEL_WIDTH = CHANNEL_WIDTH self.INIT_DATA = INIT_DATA self.NB_ACCUMULATIONS = NB_ACCUMULATIONS # Io Signals self.reset_acc = myhdl.Signal ( bool ( 0 ) ) self.pipeST_i = PipelineST ( self.DATAWIDTH, self.CHANNEL_WIDTH, self.INIT_DATA ) self.pipeST_o = PipelineST ( self.DATAWIDTH, self.CHANNEL_WIDTH, self.INIT_DATA ) # Internal Signals self.accu = PipelineST ( self.DATAWIDTH, self.CHANNEL_WIDTH, self.INIT_DATA ) # Reset value to incorporate float and myhdl.intbv formats self.zero = 0.0 if ( isinstance ( self.INIT_DATA,float ) ) else 0
def __init__(self, NB_PIPELINE_STAGES=4, DATAWIDTH=32, CHANNEL_WIDTH=1, INIT_DATA=0): self.NB_PIPELINE_STAGES = NB_PIPELINE_STAGES self.DATAWIDTH = DATAWIDTH self.CHANNEL_WIDTH = CHANNEL_WIDTH self.INIT_DATA = INIT_DATA # IO Signals self.pipeST_i = PipelineST(self.DATAWIDTH, self.CHANNEL_WIDTH, self.INIT_DATA) self.pipeST_stage_o = [ PipelineST(self.DATAWIDTH, self.CHANNEL_WIDTH, self.INIT_DATA) for i in range(self.NB_PIPELINE_STAGES) ] # Internal signals self.reset_val = 0.0 if (isinstance(self.INIT_DATA, float)) else 0
def __init__(self, NB_PIPELINE_STAGES=4, DATAWIDTH=32, CHANNEL_WIDTH=1, INIT_DATA=0, OPCODE="NOP", OPSTAGE=0): self.NB_PIPELINE_STAGES = NB_PIPELINE_STAGES self.DATAWIDTH = DATAWIDTH self.CHANNEL_WIDTH = CHANNEL_WIDTH self.INIT_DATA = INIT_DATA self.OPSTAGE = OPSTAGE self.OPCODE = OPCODE # NOP by default self.OPCODEBITS = 8 # Io Signals self.pipeST_A_stage_i = [ PipelineST(self.DATAWIDTH, self.CHANNEL_WIDTH, self.INIT_DATA) for i in range(self.NB_PIPELINE_STAGES) ] self.pipeST_B_stage_i = [ PipelineST(self.DATAWIDTH, self.CHANNEL_WIDTH, self.INIT_DATA) for i in range(self.NB_PIPELINE_STAGES) ] self.pipeST_stage_o = [ PipelineST(self.DATAWIDTH, self.CHANNEL_WIDTH, self.INIT_DATA) for i in range(self.NB_PIPELINE_STAGES) ] # Internal Signals self.objOpcode = OpCode() self.OPCODE_HEX = self.objOpcode.get(self.OPCODE) self.reset_val = 0.0 if (isinstance(self.INIT_DATA, float)) else 0
def block_connect(self, pars, reset, clk, pipe_stageA, pipe_stageB, pipest_src, io): """ CommandPipeline block """ stage = [PipelineST(pars.DATAWIDTH,pars.CHANNEL_WIDTH,pars.INIT_DATA) for i in range(pars.NB_PIPELINE_STAGES)] # Reset value to incorporate float and intbv formats reset_val = 0.0 if (isinstance(pars.INIT_DATA,float)) else 0 """ Output pipesrc instance """ data_out_inst = simple_wire_assign(pipest_src.data, io.stage_o[pars.NB_PIPELINE_STAGES-1].data) sop_out_inst = simple_wire_assign(pipest_src.sop, io.stage_o[pars.NB_PIPELINE_STAGES-1].sop) eop_out_inst = simple_wire_assign(pipest_src.eop, io.stage_o[pars.NB_PIPELINE_STAGES-1].eop) valid_out_inst = simple_wire_assign(pipest_src.valid, io.stage_o[pars.NB_PIPELINE_STAGES-1].valid) channel_out_inst = simple_wire_assign(pipest_src.channel, io.stage_o[pars.NB_PIPELINE_STAGES-1].channel) wire_stage_data_inst = [] wire_stage_sop_inst = [] wire_stage_eop_inst = [] wire_stage_valid_inst = [] wire_stage_channel_inst = [] for i in range(pars.NB_PIPELINE_STAGES): """ module outputs """ wire_stage_data_inst.append(simple_wire_assign(io.stage_o[i].data, stage[i].data)) wire_stage_sop_inst.append(simple_wire_assign(io.stage_o[i].sop, stage[i].sop)) wire_stage_eop_inst.append(simple_wire_assign(io.stage_o[i].eop, stage[i].eop)) wire_stage_valid_inst.append(simple_wire_assign(io.stage_o[i].valid, stage[i].valid)) wire_stage_channel_inst.append(simple_wire_assign(io.stage_o[i].channel, stage[i].channel)) """ Call block atomic operation on each stage """ reg_stage_inst = [] cmd=Signal(intbv(pars.OPCODE)[pars.OPCODEBITS:]) reg_stage_inst.append(self.block_atomic_oper(pars, reset, clk, cmd, pipe_stageA.stage_o[pars.STAGE_NB], pipe_stageB.stage_o[pars.STAGE_NB], stage[0])) for j in range(1,pars.NB_PIPELINE_STAGES): reg_stage_inst.append(simple_reg_assign(reset, clk, stage[j].data, reset_val, stage[j-1].data) ) reg_stage_inst.append(simple_reg_assign(reset, clk, stage[j].sop, 0, stage[j-1].sop) ) reg_stage_inst.append(simple_reg_assign(reset, clk, stage[j].eop, 0, stage[j-1].eop) ) reg_stage_inst.append(simple_reg_assign(reset, clk, stage[j].valid, 0, stage[j-1].valid) ) reg_stage_inst.append(simple_reg_assign(reset, clk, stage[j].channel, 0, stage[j-1].channel) ) return instances()
def __call__(self,pars): """ Overwrite CommandPipeline Ios """ self.stage_o = [PipelineST(pars.DATAWIDTH,pars.CHANNEL_WIDTH,pars.INIT_DATA) for i in range(pars.NB_PIPELINE_STAGES)]
def sim_command_pipeline(pars_obj): global test_decimal_shift, theta_decimal_shift #------------------ Initializing Pipeline depths --------------- NB_PIPELINE_STAGES = 5 DATAWIDTH = 32 #-------------- Simulation Initialisations --------------------- reset = Signal(bool(1)) clk = Signal(bool(0)) elapsed_time = Signal(0) clkgen = clk_driver(elapsed_time, clk, period=20) #---------------------------------------------------------------- #----------------- Initializing Pipeline Streams ---------------- # --- Pipeline Pars pars = OperandPipelinePars() pars.NB_PIPELINE_STAGES = NB_PIPELINE_STAGES pars.DATAWIDTH = DATAWIDTH pars.CHANNEL_WIDTH = 2 global floatDataBus if (True == floatDataBus): pars.INIT_DATA = 0.0 # requires floating point computation else: pars.INIT_DATA = 0 # requires intbv computation # --- Initializing Pipeline A pipe_inpA = PipelineST(pars.DATAWIDTH, pars.CHANNEL_WIDTH, pars.INIT_DATA) pipe_outA = PipelineST(pars.DATAWIDTH, pars.CHANNEL_WIDTH, pars.INIT_DATA) operand_a = OperandPipeline() ioA = OperandPipelineIo() ioA(pars) # --- Initializing Pipeline B pipe_inpB = PipelineST(pars.DATAWIDTH, pars.CHANNEL_WIDTH, pars.INIT_DATA) pipe_outB = PipelineST(pars.DATAWIDTH, pars.CHANNEL_WIDTH, pars.INIT_DATA) operand_b = OperandPipeline() ioB = OperandPipelineIo() ioB(pars) # --- Initializing Command Pipeline pipe_multRes = PipelineST(pars.DATAWIDTH, pars.CHANNEL_WIDTH, pars.INIT_DATA) multcmdFile = '../tests/mult_pipeline.list' parsMult = CommandPipelinePars() parsMult.DATAWIDTH = pars.DATAWIDTH parsMult.CHANNEL_WIDTH = pars.CHANNEL_WIDTH parsMult.INIT_DATA = pars.INIT_DATA parsMult.STAGE_NB = 1 parsMult(parsMult, multcmdFile) multPipe = CommandPipeline() ioMult = CommandPipelineIo() ioMult(pars) # ---- Initializing Accumulator Block pipe_out_acc = PipelineST(pars.DATAWIDTH, pars.CHANNEL_WIDTH, pars.INIT_DATA) parsAcc = AccumulatorPars() parsAcc.DATAWIDTH = pars.DATAWIDTH parsAcc.CHANNEL_WIDTH = pars.CHANNEL_WIDTH parsAcc.INIT_DATA = pars.INIT_DATA global LEN_THETA parsAcc.NB_ACCUMULATIONS = LEN_THETA accuPipe = Accumulator() accuPipe(parsAcc) # ---- Initializing Activation Block parsActiv = ActivationPars() parsActiv.DATAWIDTH = 3 # 0 or 1 for classification parsActiv.CHANNEL_WIDTH = pars.CHANNEL_WIDTH parsActiv.INIT_DATA = pars.INIT_DATA pipe_out_activ = PipelineST(pars.DATAWIDTH, pars.CHANNEL_WIDTH, pars.INIT_DATA) activPipe = Activation() activPipe(parsActiv) #---------------------------------------------------------------- #----------------- Connecting Pipeline Blocks ------------------- inst = [] inst.append( operand_a.block_connect(pars, reset, clk, pipe_inpA, pipe_outA, ioA)) inst.append( operand_b.block_connect(pars, reset, clk, pipe_inpB, pipe_outB, ioB)) #---------------------------------------------------------------- #----------------- Connecting Command Pipeline ------------------- # Mult Pipeline inst.append( multPipe.block_connect(parsMult, reset, clk, ioA, ioB, pipe_multRes, ioMult)) #---------------------------------------------------------------- #----------------- Connecting Accumulator -------------- # Accu inst.append( accuPipe.block_connect(parsAcc, reset, clk, 0, pipe_multRes, pipe_out_acc)) #---------------------------------------------------------------- #----------------- Connecting Activation -------------- # Simple Step Activation function inst.append( activPipe.block_step_connect(parsActiv, reset, clk, pipe_out_acc, pipe_out_activ)) #---------------------------------------------------------------- #----------------- Logistic Regression Test File ------------------- lr_test_file = "../tests/ex2data1.txt" lr_theta_file = "../tests/theta1.txt" #--- Loading Test and Theta Values test_file_list = [] theta_file_list = [] nb_training_examples = 0 # Loading test data with open(lr_test_file, 'r') as f: d0 = 1.0 # Always first element is 1 for line in f: #print line d1, d2, y = line.split(',') d0 = round(float(d0), DEF_ROUND) d1 = round(float(d1), DEF_ROUND) d2 = round(float(d2), DEF_ROUND) test_file_list.extend([d0, d1, d2]) label.extend([int(y)]) nb_training_examples += 1 #loading theta with open(lr_theta_file, 'r') as f: t0, t1, t2 = (f.read().split('\n')[0]).split(',') t0 = round(float(t0), DEF_ROUND) t1 = round(float(t1), DEF_ROUND) t2 = round(float(t2), DEF_ROUND) for i in range(nb_training_examples): theta_file_list.extend([t0, t1, t2]) # exp10 shifts done for theta and test data as per requirements when intbv used if (False == floatDataBus): test_file_list = [ int(i * (10**test_decimal_shift)) for i in test_file_list ] theta_file_list = [ int(i * (10**theta_decimal_shift)) for i in theta_file_list ] #print test_file_list #print theta_file_list #---------------------------------------------------------------- #----------------- Shift Enable for pipeData ------------------- shiftEn_i = Signal(bool(0)) @always(clk.posedge, reset.posedge) def shift_signal(): if reset: shiftEn_i.next = 1 else: shiftEn_i.next = not shiftEn_i @always_comb def shiftOperand_signal(): ioB.shiftEn_i.next = shiftEn_i ioA.shiftEn_i.next = shiftEn_i #---------------------------------------------------------------- #----------------- Reset For the Module -------------------- @always(clk.posedge) def stimulus(): if elapsed_time == 40: reset.next = 0 #---------------------------------------------------------------- #----------------- Input Data for the Modules -------------------- @always_comb def transmit_data_process(): global line_nb if (shiftEn_i == 1 and nbTA == nbTB and nbTA < MAX_NB_TRANSFERS): pipe_inpA.data.next = (test_file_list[line_nb]) pipe_inpA.valid.next = 1 pipe_inpB.data.next = (theta_file_list[line_nb]) pipe_inpB.valid.next = 1 line_nb += 1 else: pipe_inpA.valid.next = 0 pipe_inpB.valid.next = 0 #---------------------------------------------------------------- #----------------- Storing Transmitted Data -------------------- @always(clk.posedge, reset.posedge) def trans_dataA_process(): global trans_dataA, trans_dataB, nbTA if reset == 1: pass elif (pipe_inpA.valid == 1 and nbTA < MAX_NB_TRANSFERS): nbTA += 1 trans_dataA.extend([pipe_inpA.data]) @always(clk.posedge, reset.posedge) def trans_dataB_process(): global trans_dataA, trans_dataB, nbTB if reset == 1: pass elif (pipe_inpB.valid == 1 and nbTB < MAX_NB_TRANSFERS): nbTB += 1 trans_dataB.extend([pipe_inpB.data]) #---------------------------------------------------------------- #----------------- Storing Received Data ----------------------- @always(clk.posedge) def receive_data_process(): global recv_data, nbR, acc_out # Collecting multiplier data if (pipe_multRes.valid == 1): if (False == floatDataBus): mult_out = pipe_multRes.data else: mult_out = (round(pipe_multRes.data, DEF_ROUND)) recv_data.extend([mult_out]) # Collecting Activation Data if (pipe_out_activ.valid == 1): nbR += LEN_THETA predict = int(pipe_out_activ.data) prediction_res.extend([predict]) if __debug__: print(" prediction: {:d}".format(predict)) if (nbR == MAX_NB_TRANSFERS): raise StopSimulation( "Simulation Finished in %d clks: In total " % now() + str(MAX_NB_TRANSFERS) + " data words received") # Collecting Accumulator Data if (pipe_out_acc.valid == 1): acc_out = pipe_out_acc.data #prob=(1.0/(1+ (math.exp(-1.0*acc_out) ))) # Sigmoid activation Function if __debug__: if (False == floatDataBus): print("{0:d} Acc: {1:d} ".format(int(nbR / LEN_THETA + 1), int(acc_out), i=DEF_ROUND), end=' ') else: print("{0:d} Acc: {1:0.{i}f}".format(int(nbR / LEN_THETA + 1), float(acc_out), i=DEF_ROUND), end=' ') if (False == floatDataBus): acc_out_list.extend([int(acc_out)]) else: acc_out_list.extend([round(acc_out, DEF_ROUND)]) #print "nbR:" + str(nbR) #---------------------------------------------------------------- #----------------- Max Simulation Time Exit Condition ----------- @always(clk.posedge) def simulation_time_check(): sim_time_now = now() if (sim_time_now > MAX_SIM_TIME): raise StopSimulation( "Warning! Simulation Exited upon reaching max simulation time of " + str(MAX_SIM_TIME) + " clocks") #---------------------------------------------------------------- return instances()
def lr_top(pars, reset, clk, pipe_inpA, pipe_inpB, pipe_out_activ): #----------------- Initializing Pipeline Streams ---------------- # --- Initializing Pipeline A pipe_outA = PipelineST(pars.DATAWIDTH,pars.CHANNEL_WIDTH,pars.INIT_DATA) operand_a=OperandPipeline() ioA=OperandPipelineIo() ioA(pars) # --- Initializing Pipeline B pipe_outB = PipelineST(pars.DATAWIDTH,pars.CHANNEL_WIDTH,pars.INIT_DATA) operand_b=OperandPipeline() ioB=OperandPipelineIo() ioB(pars) # --- Initializing Command Pipeline pipe_multRes = PipelineST(pars.DATAWIDTH,pars.CHANNEL_WIDTH,pars.INIT_DATA) multcmdFile='tb/tests/mult_pipeline.list' parsMult= CommandPipelinePars() parsMult.DATAWIDTH= pars.DATAWIDTH parsMult.CHANNEL_WIDTH = pars.CHANNEL_WIDTH parsMult.INIT_DATA = pars.INIT_DATA parsMult.STAGE_NB = 1 parsMult(parsMult,multcmdFile) multPipe=CommandPipeline() ioMult=CommandPipelineIo() ioMult(pars) # ---- Initializing Accumulator Block pipe_out_acc = PipelineST(pars.DATAWIDTH,pars.CHANNEL_WIDTH,pars.INIT_DATA) parsAcc= AccumulatorPars() parsAcc.DATAWIDTH= pars.DATAWIDTH parsAcc.CHANNEL_WIDTH = pars.CHANNEL_WIDTH parsAcc.INIT_DATA = pars.INIT_DATA parsAcc.NB_ACCUMULATIONS = pars.LEN_THETA accuPipe= Accumulator() accuPipe(parsAcc) # ---- Initializing Activation Block parsActiv= ActivationPars() parsActiv.DATAWIDTH= 3 # 0 or 1 for classification parsActiv.CHANNEL_WIDTH = pars.CHANNEL_WIDTH parsActiv.INIT_DATA = pars.INIT_DATA activPipe= Activation() activPipe(parsActiv) #---------------------------------------------------------------- #----------------- Connecting Pipeline Blocks ------------------- trainingData=(operand_a.block_connect(pars, reset, clk, pipe_inpA, pipe_outA, ioA)) theta=(operand_b.block_connect(pars, reset, clk, pipe_inpB, pipe_outB, ioB)) #---------------------------------------------------------------- #----------------- Connecting Command Pipeline ------------------- # Mult Pipeline command=(multPipe.block_connect(parsMult, reset, clk, ioA, ioB, pipe_multRes, ioMult)) #---------------------------------------------------------------- #----------------- Connecting Accumulator -------------- # Accu acc_reset=Signal(bool(0)) accumulator=(accuPipe.block_connect(parsAcc, reset, clk, acc_reset, pipe_multRes, pipe_out_acc)) #---------------------------------------------------------------- #----------------- Connecting Activation -------------- # Simple Step Activation function activation=(activPipe.block_step_connect(parsActiv, reset, clk, pipe_out_acc, pipe_out_activ )) #---------------------------------------------------------------- return instances()
def sim_operand_pipeline(pars_obj): NB_PIPELINE_STAGES = 10 DATAWIDTH = 32 reset = Signal(bool(1)) clk = Signal(bool(0)) elapsed_time = Signal(0) clkgen = clk_driver(elapsed_time, clk, period=20) pipe_inpA = PipelineST(DATAWIDTH) pipe_outA = PipelineST(DATAWIDTH) pipe_inpB = PipelineST(DATAWIDTH) pipe_outB = PipelineST(DATAWIDTH) operand_a = OperandPipeline() pars = OperandPipelinePars() pars.NB_PIPELINE_STAGES = NB_PIPELINE_STAGES pars.DATAWIDTH = DATAWIDTH pars(pars) ioA = OperandPipelineIo() ioA(pars) inst = [] inst.append( operand_a.block_connect(pars, reset, clk, pipe_inpA, pipe_outA, ioA)) operand_b = OperandPipeline() ioB = OperandPipelineIo() ioB(pars) inst.append( operand_b.block_connect(pars, reset, clk, pipe_inpB, pipe_outB, ioB)) mult = Signal(intbv(DATAWIDTH + DATAWIDTH)) @always(clk.posedge, reset.posedge) def mult_process(): if reset == 1: mult.next = intbv(0) elif (ioA.stage_o[5].valid == 1 and ioB.stage_o[5].valid == 1): mult.next = mult + ioA.stage_o[5].data * ioB.stage_o[5].data shiftEn_i = Signal(bool(0)) @always(clk.posedge) def shift_signal(): shiftEn_i.next = not shiftEn_i @always_comb def shiftOperand_signal(): ioB.shiftEn_i.next = shiftEn_i ioA.shiftEn_i.next = shiftEn_i @always(clk.posedge) def stimulus(): if elapsed_time == 40: reset.next = 0 INIT_DATA = 1 data_in = Signal(int(0)) @always_comb def transmit_data_process(): if (shiftEn_i == 1 and nb1 < MAX_NB_TRANSFERS): pipe_inpA.data.next = data_in pipe_inpA.valid.next = 1 pipe_inpB.data.next = data_in pipe_inpB.valid.next = 1 else: pipe_inpA.valid.next = 0 pipe_inpB.valid.next = 0 #Dataout is just an increment (for next valid data) @always(clk.posedge, reset.posedge) def transmit_data_clk_process(): global trans_data, nb1 if reset == 1: data_in.next = int(INIT_DATA) elif (shiftEn_i == 1 and nb1 < MAX_NB_TRANSFERS): nb1 += 1 #print str(nb1) + ". Transmitted data to src bfm:", ": ", src_bfm_i.data_i trans_data.append(int(data_in)) data_in.next = data_in + 1 @always(clk.posedge) def receive_data_process(): global recv_data, nb2 if (pipe_outA.valid == 1): nb2 += 1 #print str(nb2) + ". Received data from sink bfm:", ": ", src_bfm_o.data_o recv_data.append(int(pipe_outA.data)) sim_time_now = now() if (nb2 == MAX_NB_TRANSFERS + NB_PIPELINE_STAGES): raise StopSimulation( "Simulation Finished in %d clks: In total " % now() + str(MAX_NB_TRANSFERS) + " data words received") @always(clk.posedge) def simulation_time_check(): sim_time_now = now() if (sim_time_now > MAX_SIM_TIME): raise StopSimulation( "Warning! Simulation Exited upon reaching max simulation time of " + str(MAX_SIM_TIME) + " clocks") return instances()
def __init__( self , NB_PIPELINE_STAGES = 4, DATAWIDTH = 32, CHANNEL_WIDTH = 1, INIT_DATA = 0, LEN_THETA = 3, CMD_FILE = ""): self.NB_PIPELINE_STAGES = NB_PIPELINE_STAGES self.DATAWIDTH = DATAWIDTH self.CHANNEL_WIDTH = CHANNEL_WIDTH self.INIT_DATA = INIT_DATA self.LEN_THETA = LEN_THETA self.CMD_FILE = CMD_FILE # IO Signals self.pipeST_A_i = PipelineST( self.DATAWIDTH, self.CHANNEL_WIDTH , self.INIT_DATA ) self.pipeST_B_i = PipelineST( self.DATAWIDTH, self.CHANNEL_WIDTH , self.INIT_DATA ) self.pipeST_o = PipelineST( self.DATAWIDTH, self.CHANNEL_WIDTH , self.INIT_DATA ) # Internal Signals self.pipe_out_acc = PipelineST( self.DATAWIDTH, self.CHANNEL_WIDTH, self.INIT_DATA ) #----------------- Initializing Pipeline Streams ---------------- self.operand_a = OperandPipeline( self.NB_PIPELINE_STAGES , self.DATAWIDTH , self.CHANNEL_WIDTH , self.INIT_DATA ) self.pipeA_stage = self.operand_a.pipeST_stage_o self.operand_b = OperandPipeline( self.NB_PIPELINE_STAGES , self.DATAWIDTH , self.CHANNEL_WIDTH , self.INIT_DATA ) self.pipeB_stage = self.operand_b.pipeST_stage_o # --- Initializing Command Pipeline OPCODE = "MULT" OPSTAGE = 2 self.multPipe = CommandPipeline( self.NB_PIPELINE_STAGES , self.DATAWIDTH , self.CHANNEL_WIDTH , self.INIT_DATA , OPCODE , OPSTAGE ) self.multC_stage = self.multPipe.pipeST_stage_o # ---- Initializing Accumulator Block self.accuPipe = Accumulator( self.DATAWIDTH , self.CHANNEL_WIDTH , self.INIT_DATA , self.LEN_THETA ) # ---- Initializing Activation Block ACT_DATAWIDTH= 3 # 0 or 1 for classification self.activPipe = Activation( ACT_DATAWIDTH , self.CHANNEL_WIDTH , self.INIT_DATA )