Cheri-research/Toooba
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

Incremental additions to Tandem Verification trace gen

Browse Source
This commit is contained in:
rsnikhil
2020-02-06 20:46:26 -05:00
parent c14c9b3e6c
commit af0b1ef415
8 changed files with 21387 additions and 20319 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src_Core/Core/Trace_Data2.bsv
View File

@@ -24,9 +24,10 @@ import ReorderBuffer :: *;
// add to the critical path or scheduling requirements of CommitStage.
typedef struct {
Bit #(64) serialnum; // instruction serial number
Bit #(64) serial_num; // TV message serial number
Addr pc;
Bit #(32) orig_inst; // original 16b or 32b instruction ([1:0] will distinguish 16b or 32b)
Maybe#(ArchRIndx) dst; // Invalid, GPR or FPR destination ("Rd")
IType iType;
Maybe #(CSR) csr;
Maybe #(Trap) trap;

147
src_Core/Core/Trace_Data2_to_Trace_Data.bsv
View File

@@ -4,7 +4,7 @@ package Trace_Data2_to_Trace_Data;
// ================================================================
// This package defines a module to transform a stream of Trace_Data2
// to a stream of (serialnum, Trace_Data)
// to a stream of (serial_num, Trace_Data)
// ================================================================
// BSV library imports
@@ -35,11 +35,10 @@ import Trace_Data2 :: *;
// ================================================================
interface Trace_Data2_to_Trace_Data_IFC;
method Action init;
// From Toooba's CommitStage
interface Put #(Trace_Data2) in;
// To Trace Encoder
interface Get #(Tuple2 #(Bit #(64), Trace_Data)) out;
endinterface
@@ -48,7 +47,7 @@ endinterface
(* synthesize *)
module mkTrace_Data2_to_Trace_Data (Trace_Data2_to_Trace_Data_IFC);
Integer verbosity = 0; // for debugging
Integer verbosity = 1; // for debugging
// Input stream
FIFOF #(Trace_Data2) f_in <- mkFIFOF;
@@ -57,84 +56,154 @@ module mkTrace_Data2_to_Trace_Data (Trace_Data2_to_Trace_Data_IFC);
FIFOF #(Tuple2 #(Bit #(64), Trace_Data)) f_out <- mkFIFOF;
// ================================================================
// Transformer: Trace_Data2 -> (serialnum, Trace_Data)
// Transformer: Trace_Data2 -> (serial_num, Trace_Data)
function ActionValue #(Tuple2 #(Bit #(64), Trace_Data)) fav_xform (Trace_Data2 td2);
function ActionValue #(Tuple2 #(Bit #(64), Trace_Data)) fav_td2_to_td (Trace_Data2 td2);
actionvalue
let serialnum = td2.serialnum;
Trace_Data td = ?;
ISize isize = ((td2.orig_inst [1:0] == 2'b11) ? ISIZE32BIT : ISIZE16BIT);
let serial_num = td2.serial_num;
Trace_Data td = ?;
ISize isize = ((td2.orig_inst [1:0] == 2'b11) ? ISIZE32BIT : ISIZE16BIT);
Addr fall_thru_PC = td2.pc + ((td2.orig_inst [1:0] == 2'b11) ? 4 : 2);
if ( (td2.iType == Alu)
|| (td2.iType == J)
|| (td2.iType == Jr)
|| (td2.iType == Auipc))
td = mkTrace_I_RD (td2.pc,
Bit #(5) gpr_rd = 0;
if (td2.dst matches tagged Valid (tagged Gpr .r)) gpr_rd = r;
if (serial_num == 0)
td = mkTrace_RESET;
else if (td2.ppc_vaddr_csrData matches tagged PPC .target_addr
&&& (td2.iType == Br))
td = mkTrace_OTHER (target_addr, isize, td2.orig_inst);
else if (td2.ppc_vaddr_csrData matches tagged PPC .target_addr
&&& ( (td2.iType == J)
|| (td2.iType == Jr)))
td = mkTrace_I_RD (target_addr,
isize,
td2.orig_inst,
0, // TODO: rd
gpr_rd,
0); // TODO: return-pc
else if ( (td2.iType == Alu)
|| (td2.iType == Auipc))
td = mkTrace_I_RD (fall_thru_PC,
isize,
td2.orig_inst,
gpr_rd,
0); // TODO: rd_val
else if ( (td2.iType == Br)
|| (td2.iType == Fence)
else if (td2.dst matches tagged Valid (tagged Fpu .fpr_rd)
&&& (td2.iType == Fpu))
td = mkTrace_F_FRD (fall_thru_PC,
isize,
td2.orig_inst,
fpr_rd,
?, // TODO: rdval
?, // TODO: Bit#(5) fflags
?); // TODO: mstatus)
else if (td2.iType == Fpu)
td = mkTrace_F_GRD (fall_thru_PC,
isize,
td2.orig_inst,
gpr_rd,
?, // TODO: rdval
?, // TODO: Bit#(5) fflags
?); // TODO: mstatus)
else if (td2.ppc_vaddr_csrData matches tagged VAddr .eaddr
&&& (td2.iType == Ld))
td = mkTrace_I_LOAD (fall_thru_PC,
isize,
td2.orig_inst,
gpr_rd,
?, // TODO: rd_val
eaddr);
else if (td2.ppc_vaddr_csrData matches tagged VAddr .eaddr
&&& (td2.iType == St))
td = mkTrace_I_STORE (fall_thru_PC,
?, // TODO: funct3,
isize,
td2.orig_inst,
?, // store-value
eaddr);
else if (td2.ppc_vaddr_csrData matches tagged CSRData .csr_data
&&& (td2.iType == Csr))
begin
Bool csr_valid = False;
CSR_Addr csr_addr = 0;
if (td2.csr matches tagged Valid .c) begin
csr_valid = True;
csr_addr = pack (c);
end
td = mkTrace_CSRRX (fall_thru_PC,
isize,
td2.orig_inst,
gpr_rd,
?, // TODO: rdval
csr_valid,
csr_addr,
csr_data);
end
else if ( (td2.iType == Fence)
|| (td2.iType == FenceI)
|| (td2.iType == SFence)
|| (td2.iType == Ecall)
|| (td2.iType == Ebreak)
|| (td2.iType == Mret)
|| (td2.iType == Sret))
td = mkTrace_OTHER (td2.pc, isize, td2.orig_inst);
td = mkTrace_OTHER (fall_thru_PC, isize, td2.orig_inst);
else if ( (td2.iType == Amo)
|| (td2.iType == Lr)
|| (td2.iType == Sc))
td = mkTrace_AMO (td2.pc,
td = mkTrace_AMO (fall_thru_PC,
0, // TODO: funct3
isize,
td2.orig_inst,
0, // TODO: rd
gpr_rd,
0, // TODO: rd_val
0, // TODO: rs2_val
0 // TODO: eaddr
);
else if ( (td2.iType == Unsupported)
|| (td2.iType == Nop)
|| (td2.iType == Interrupt))
td = mkTrace_OTHER (fall_thru_PC, isize, td2.orig_inst);
else begin
if (verbosity != 0) begin
$display (" fav_xform: TBD: Using mkTrace_I_RD for now");
if (verbosity > 0) begin
$display (" fav_td2_to_td: TBD: Unknown iType: Using mkTrace_OTHER for now");
$display (" ", fshow (td2));
end
td = mkTrace_I_RD (td2.pc,
isize,
td2.orig_inst,
0, // TODO: rd
0); // TODO: rd_val
td = mkTrace_OTHER (fall_thru_PC, isize, td2.orig_inst);
end
return tuple2 (serialnum, td);
return tuple2 (serial_num, td);
endactionvalue
endfunction
// ================================================================
// RULES
rule rl_xform;
rule rl_td2_to_td;
Trace_Data2 td2 <- pop (f_in);
if (verbosity != 0)
$display ("%0d: %m.rl_xform: serialnum:%0d PC:0x%0h instr:0x%08h",
cur_cycle, td2.serialnum, td2.pc, td2.orig_inst,
if (verbosity > 1)
$display ("%0d: %m.rl_td2_to_td: serial_num:%0d PC:0x%0h instr:0x%08h",
cur_cycle, td2.serial_num, td2.pc, td2.orig_inst,
" iType:", fshow (td2.iType));
match { .serialnum, .td } <- fav_xform (td2);
f_out.enq (tuple2 (serialnum, td));
match { .serial_num, .td } <- fav_td2_to_td (td2);
f_out.enq (tuple2 (serial_num, td));
endrule
// ================================================================
// INTERFACE
method Action init;
f_in.clear;
f_out.clear;
endmethod
interface in = toPut (f_in);
interface out = toGet (f_out);
endmodule

40
src_Core/RISCY_OOO/procs/RV64G_OOO/CommitStage.bsv
View File

@@ -158,20 +158,21 @@ module mkCommitStage#(CommitInput inIfc)(CommitStage);
Integer verbosity = 1; // Bluespec: for lightweight verbosity trace
// Used to inform tandem-verifier about program order.
// 0 is used to indicate we've just come out of reset
// TODO: we could use fewer bits and allow and recognize wraparound.
Reg #(Bit #(64)) rg_serialnum <- mkReg (0);
Reg #(Bit #(64)) rg_serial_num <- mkReg (0);
`ifdef INCLUDE_GDB_CONTROL
Reg #(Run_State) rg_run_state <- mkReg (RUN_STATE_RUNNING);
`endif
`ifdef INCLUDE_TANDEM_VERIF
function Action fa_to_TV (Bit #(64) serialnum, ToReorderBuffer deq_data, Integer way);
function Action fa_to_TV (Bit #(64) serial_num, ToReorderBuffer deq_data, Integer way);
action
let x = Trace_Data2 {serialnum: serialnum,
let x = Trace_Data2 {serial_num: serial_num,
pc: deq_data.pc,
orig_inst: deq_data.orig_inst,
dst: deq_data.dst,
iType: deq_data.iType,
csr: deq_data.csr,
trap: deq_data.trap,
@@ -182,6 +183,14 @@ module mkCommitStage#(CommitInput inIfc)(CommitStage);
inIfc.v_to_TV [way].put (x);
endaction
endfunction
Reg #(Bool) rg_just_after_reset <- mkReg (True);
rule rl_send_tv_reset (rg_just_after_reset);
fa_to_TV (0, ?, 0);
rg_just_after_reset <= False;
rg_serial_num <= 1;
endrule
`endif
// func units
@@ -467,7 +476,7 @@ module mkCommitStage#(CommitInput inIfc)(CommitStage);
commitTrap <= commitTrap_val;
if (verbosity >= 1) begin
$display ("instret:%0d PC:0x%0h instr:0x%08h", rg_serialnum, x.pc, x.orig_inst,
$display ("instret:%0d PC:0x%0h instr:0x%08h", rg_serial_num, x.pc, x.orig_inst,
" iType:", fshow (x.iType), " [doCommitTrap]");
end
if (verbose) begin
@@ -476,9 +485,9 @@ module mkCommitStage#(CommitInput inIfc)(CommitStage);
end
`ifdef INCLUDE_TANDEM_VERIF
fa_to_TV (rg_serialnum, x, 0);
fa_to_TV (rg_serial_num, x, 0);
`endif
rg_serialnum <= rg_serialnum + 1;
rg_serial_num <= rg_serial_num + 1;
// flush everything. Only increment epoch and stall fetch when we haven
// not done it yet (we may have already done them at rename stage)
@@ -629,14 +638,14 @@ module mkCommitStage#(CommitInput inIfc)(CommitStage);
if(verbose) $display("[doCommitSystemInst] ", fshow(x));
if (verbosity >= 1) begin
$display("instret:%0d PC:0x%0h instr:0x%08h", rg_serialnum, x.pc, x.orig_inst,
$display("instret:%0d PC:0x%0h instr:0x%08h", rg_serial_num, x.pc, x.orig_inst,
" iType:", fshow (x.iType), " [doCommitSystemInst]");
end
`ifdef INCLUDE_TANDEM_VERIF
fa_to_TV (rg_serialnum, x, 0);
fa_to_TV (rg_serial_num, x, 0);
`endif
rg_serialnum <= rg_serialnum + 1;
rg_serial_num <= rg_serial_num + 1;
// we claim a phy reg for every inst, so commit its renaming
regRenamingTable.commit[0].commit;
@@ -798,13 +807,13 @@ module mkCommitStage#(CommitInput inIfc)(CommitStage);
if (verbose) $display("[doCommitNormalInst - %d] ", i, fshow(inst_tag), " ; ", fshow(x));
if (verbosity >= 1) begin
$display("instret:%0d PC:0x%0h instr:0x%08h", rg_serialnum + instret, x.pc, x.orig_inst,
$display("instret:%0d PC:0x%0h instr:0x%08h", rg_serial_num + instret, x.pc, x.orig_inst,
" iType:", fshow (x.iType), " [doCommitNormalInst [%0d]]", i);
end
`ifdef INCLUDE_TANDEM_VERIF
fa_to_TV (rg_serialnum + instret, x, i);
fa_to_TV (rg_serial_num + instret, x, i);
`endif
instret = instret + 1;
instret = instret + 1;
// inst can be committed, deq it
rob.deqPort[i].deq;
@@ -857,7 +866,7 @@ module mkCommitStage#(CommitInput inIfc)(CommitStage);
end
end
end
rg_serialnum <= rg_serialnum + instret;
rg_serial_num <= rg_serial_num + instret;
// write FPU csr
if(csrf.fpuInstNeedWr(fflags, will_dirty_fpu_state)) begin
@@ -904,6 +913,9 @@ module mkCommitStage#(CommitInput inIfc)(CommitStage);
`endif
endrule
// ================================================================
// INTERFACE
method Data getPerf(ComStagePerfType t);
return (case(t)
`ifdef PERF_COUNT

5
src_Core/RISCY_OOO/procs/RV64G_OOO/RenameStage.bsv
View File

@@ -347,6 +347,7 @@ module mkRenameStage#(RenameInput inIfc)(RenameStage);
// just place it in the reorder buffer
let y = ToReorderBuffer{pc: pc,
orig_inst: orig_inst,
dst: arch_regs.dst,
iType: dInst.iType,
csr: dInst.csr,
claimed_phy_reg: False, // no renaming is done
@@ -446,6 +447,7 @@ module mkRenameStage#(RenameInput inIfc)(RenameStage);
let x = fetchStage.pipelines[0].first;
let pc = x.pc;
let orig_inst = x.orig_inst;
let dst = x.regs.dst;
let ppc = x.ppc;
let main_epoch = x.main_epoch;
let dpTrain = x.dpTrain;
@@ -520,6 +522,7 @@ module mkRenameStage#(RenameInput inIfc)(RenameStage);
RobInstState rob_inst_state = to_exec ? NotDone : Executed;
let y = ToReorderBuffer{pc: pc,
orig_inst: orig_inst,
dst: arch_regs.dst,
iType: dInst.iType,
csr: dInst.csr,
claimed_phy_reg: True, // XXX we always claim a free reg in rename
@@ -685,6 +688,7 @@ module mkRenameStage#(RenameInput inIfc)(RenameStage);
RobInstState rob_inst_state = NotDone; // mem inst always needs execution
let y = ToReorderBuffer{pc: pc,
orig_inst: orig_inst,
dst: arch_regs.dst,
iType: dInst.iType,
csr: dInst.csr,
claimed_phy_reg: True, // XXX we always claim a free reg in rename
@@ -1037,6 +1041,7 @@ module mkRenameStage#(RenameInput inIfc)(RenameStage);
let y = ToReorderBuffer{pc: pc,
orig_inst: orig_inst,
dst: arch_regs.dst,
iType: dInst.iType,
csr: dInst.csr,
claimed_phy_reg: True, // XXX we always claim a free reg in rename

4
src_Core/RISCY_OOO/procs/lib/ReorderBuffer.bsv
View File

@@ -47,6 +47,7 @@ typedef union tagged {
typedef struct {
Addr pc;
Bit #(32) orig_inst; // original 16b or 32b instruction ([1:0] will distinguish 16b or 32b)
Maybe#(ArchRIndx) dst; // Invalid, GPR or FPR destination ("Rd")
IType iType;
Maybe#(CSR) csr;
Bool claimed_phy_reg; // whether we need to commmit renaming
@@ -170,6 +171,7 @@ module mkReorderBufferRowEhr(ReorderBufferRowEhr#(aluExeNum, fpuMulDivExeNum)) p
Reg#(Addr) pc <- mkRegU;
Reg #(Bit #(32)) orig_inst <- mkRegU;
Reg #(Maybe #(ArchRIndx)) rg_dst_reg <- mkRegU;
Reg#(IType) iType <- mkRegU;
Reg#(Maybe#(CSR)) csr <- mkRegU;
Reg#(Bool) claimed_phy_reg <- mkRegU;
@@ -259,6 +261,7 @@ module mkReorderBufferRowEhr(ReorderBufferRowEhr#(aluExeNum, fpuMulDivExeNum)) p
method Action write_enq(ToReorderBuffer x);
pc <= x.pc;
orig_inst <= x.orig_inst;
rg_dst_reg <= x.dst;
iType <= x.iType;
csr <= x.csr;
claimed_phy_reg <= x.claimed_phy_reg;
@@ -292,6 +295,7 @@ module mkReorderBufferRowEhr(ReorderBufferRowEhr#(aluExeNum, fpuMulDivExeNum)) p
return ToReorderBuffer {
pc: pc,
orig_inst: orig_inst,
dst: rg_dst_reg,
iType: iType,
csr: csr,
claimed_phy_reg: claimed_phy_reg,