66a67,87
>
> void
> setupSharedData()
> {
> int shmfd = shmget('M' << 24 | getuid(), sizeof(SharedData), 0777);
> if (shmfd < 0)
> fatal("Couldn't get shared memory fd. Is Legion running?");
>
> shared_data = (SharedData*)shmat(shmfd, NULL, SHM_RND);
> if (shared_data == (SharedData*)-1)
> fatal("Couldn't allocate shared memory");
>
> if (shared_data->flags != OWN_M5)
> fatal("Shared memory has invalid owner");
>
> if (shared_data->version != VERSION)
> fatal("Shared Data is wrong version! M5: %d Legion: %d", VERSION,
> shared_data->version);
>
> // step legion forward one cycle so we can get register values
> shared_data->flags = OWN_LEGION;
131c152
< if (flags[PRINT_REG_DELTA])
---
> if (IsOn(ExecRegDelta))
192,208c213,219
< else if (flags[INTEL_FORMAT]) {
< #if FULL_SYSTEM
< bool is_trace_system = (thread->getCpuPtr()->system->name() == trace_system);
< #else
< bool is_trace_system = true;
< #endif
< if (is_trace_system) {
< ccprintf(outs, "%7d ) ", when);
< outs << "0x" << hex << PC << ":\t";
< if (staticInst->isLoad()) {
< outs << "<RD 0x" << hex << addr;
< outs << ">";
< } else if (staticInst->isStore()) {
< outs << "<WR 0x" << hex << addr;
< outs << ">";
< }
< outs << endl;
---
> else if (IsOn(ExecIntel)) {
> ccprintf(outs, "%7d ) ", when);
> outs << "0x" << hex << PC << ":\t";
> if (staticInst->isLoad()) {
> ccprintf(outs, "<RD %#x>", addr);
> } else if (staticInst->isStore()) {
> ccprintf(outs, "<WR %#x>", addr);
209a221
> outs << endl;
211c223
< if (flags[PRINT_TICKS])
---
> if (IsOn(ExecTicks))
216c228
< if (flags[TRACE_MISSPEC])
---
> if (IsOn(ExecSpeculative))
219c231
< if (flags[PRINT_THREAD_NUM])
---
> if (IsOn(ExecThread))
227c239
< && flags[PC_SYMBOL]) {
---
> && IsOn(ExecSymbol)) {
253c265
< if (flags[PRINT_OP_CLASS]) {
---
> if (IsOn(ExecOpClass)) {
257c269
< if (flags[PRINT_RESULT_DATA] && data_status != DataInvalid) {
---
> if (IsOn(ExecResult) && data_status != DataInvalid) {
269c281
< if (flags[PRINT_EFF_ADDR] && addr_valid)
---
> if (IsOn(ExecEffAddr) && addr_valid)
272c284
< if (flags[PRINT_INT_REGS] && regs_valid) {
---
> if (IsOn(ExecIntRegs) && regs_valid) {
281c293
< if (flags[PRINT_FETCH_SEQ] && fetch_seq_valid)
---
> if (IsOn(ExecFetchSeq) && fetch_seq_valid)
284c296
< if (flags[PRINT_CP_SEQ] && cp_seq_valid)
---
> if (IsOn(ExecCPSeq) && cp_seq_valid)
294c306
< if (flags[LEGION_LOCKSTEP])
---
> if (IsOn(ExecLegion))
325a338,340
> if (!shared_data)
> setupSharedData();
>
689,795c704
<
< vector<bool> Trace::InstRecord::flags(NUM_BITS);
< string Trace::InstRecord::trace_system;
<
< ////////////////////////////////////////////////////////////////////////
< //
< // Parameter space for per-cycle execution address tracing options.
< // Derive from ParamContext so we can override checkParams() function.
< //
< class ExecutionTraceParamContext : public ParamContext
< {
< public:
< ExecutionTraceParamContext(const string &_iniSection)
< : ParamContext(_iniSection)
< {
< }
<
< void checkParams(); // defined at bottom of file
< };
<
< ExecutionTraceParamContext exeTraceParams("exetrace");
<
< Param<bool> exe_trace_spec(&exeTraceParams, "speculative",
< "capture speculative instructions", true);
<
< Param<bool> exe_trace_print_cycle(&exeTraceParams, "print_cycle",
< "print cycle number", true);
< Param<bool> exe_trace_print_opclass(&exeTraceParams, "print_opclass",
< "print op class", true);
< Param<bool> exe_trace_print_thread(&exeTraceParams, "print_thread",
< "print thread number", true);
< Param<bool> exe_trace_print_effaddr(&exeTraceParams, "print_effaddr",
< "print effective address", true);
< Param<bool> exe_trace_print_data(&exeTraceParams, "print_data",
< "print result data", true);
< Param<bool> exe_trace_print_iregs(&exeTraceParams, "print_iregs",
< "print all integer regs", false);
< Param<bool> exe_trace_print_fetchseq(&exeTraceParams, "print_fetchseq",
< "print fetch sequence number", false);
< Param<bool> exe_trace_print_cp_seq(&exeTraceParams, "print_cpseq",
< "print correct-path sequence number", false);
< Param<bool> exe_trace_print_reg_delta(&exeTraceParams, "print_reg_delta",
< "print which registers changed to what", false);
< Param<bool> exe_trace_pc_symbol(&exeTraceParams, "pc_symbol",
< "Use symbols for the PC if available", true);
< Param<bool> exe_trace_intel_format(&exeTraceParams, "intel_format",
< "print trace in intel compatible format", false);
< Param<bool> exe_trace_legion_lockstep(&exeTraceParams, "legion_lockstep",
< "Compare sim state to legion state every cycle",
< false);
< Param<string> exe_trace_system(&exeTraceParams, "trace_system",
< "print trace of which system (client or server)",
< "client");
<
<
< //
< // Helper function for ExecutionTraceParamContext::checkParams() just
< // to get us into the InstRecord namespace
< //
< void
< Trace::InstRecord::setParams()
< {
< flags[TRACE_MISSPEC] = exe_trace_spec;
<
< flags[PRINT_TICKS] = exe_trace_print_cycle;
< flags[PRINT_OP_CLASS] = exe_trace_print_opclass;
< flags[PRINT_THREAD_NUM] = exe_trace_print_thread;
< flags[PRINT_RESULT_DATA] = exe_trace_print_effaddr;
< flags[PRINT_EFF_ADDR] = exe_trace_print_data;
< flags[PRINT_INT_REGS] = exe_trace_print_iregs;
< flags[PRINT_FETCH_SEQ] = exe_trace_print_fetchseq;
< flags[PRINT_CP_SEQ] = exe_trace_print_cp_seq;
< flags[PRINT_REG_DELTA] = exe_trace_print_reg_delta;
< flags[PC_SYMBOL] = exe_trace_pc_symbol;
< flags[INTEL_FORMAT] = exe_trace_intel_format;
< flags[LEGION_LOCKSTEP] = exe_trace_legion_lockstep;
< trace_system = exe_trace_system;
<
< // If were going to be in lockstep with Legion
< // Setup shared memory, and get otherwise ready
< if (flags[LEGION_LOCKSTEP]) {
< int shmfd = shmget('M' << 24 | getuid(), sizeof(SharedData), 0777);
< if (shmfd < 0)
< fatal("Couldn't get shared memory fd. Is Legion running?");
<
< shared_data = (SharedData*)shmat(shmfd, NULL, SHM_RND);
< if (shared_data == (SharedData*)-1)
< fatal("Couldn't allocate shared memory");
<
< if (shared_data->flags != OWN_M5)
< fatal("Shared memory has invalid owner");
<
< if (shared_data->version != VERSION)
< fatal("Shared Data is wrong version! M5: %d Legion: %d", VERSION,
< shared_data->version);
<
< // step legion forward one cycle so we can get register values
< shared_data->flags = OWN_LEGION;
< }
< }
<
< void
< ExecutionTraceParamContext::checkParams()
< {
< Trace::InstRecord::setParams();
< }
<
---
> /* namespace Trace */ }