diff options
-rw-r--r-- | arch/alpha/fake_syscall.cc | 296 | ||||
-rw-r--r-- | arch/alpha/isa_desc | 20 | ||||
-rw-r--r-- | base/misc.cc | 12 | ||||
-rw-r--r-- | base/statistics.cc | 15 | ||||
-rw-r--r-- | base/statistics.hh | 16 | ||||
-rw-r--r-- | cpu/exec_context.cc | 3 | ||||
-rw-r--r-- | cpu/exec_context.hh | 8 | ||||
-rw-r--r-- | cpu/exetrace.cc | 4 | ||||
-rw-r--r-- | cpu/simple_cpu/simple_cpu.cc | 27 | ||||
-rw-r--r-- | cpu/simple_cpu/simple_cpu.hh | 2 | ||||
-rw-r--r-- | dev/etherlink.cc | 2 | ||||
-rw-r--r-- | kern/tru64/tru64_events.cc | 50 | ||||
-rw-r--r-- | kern/tru64/tru64_events.hh | 17 | ||||
-rw-r--r-- | kern/tru64/tru64_system.cc | 375 | ||||
-rw-r--r-- | kern/tru64/tru64_system.hh | 81 | ||||
-rw-r--r-- | sim/system.cc | 38 | ||||
-rw-r--r-- | sim/system.hh | 34 |
17 files changed, 899 insertions, 101 deletions
diff --git a/arch/alpha/fake_syscall.cc b/arch/alpha/fake_syscall.cc index b2e42daaf..43bb0a9cc 100644 --- a/arch/alpha/fake_syscall.cc +++ b/arch/alpha/fake_syscall.cc @@ -31,6 +31,7 @@ #include <sys/types.h> #include <sys/stat.h> #include <string.h> // for memset() +#include <dirent.h> #include "sim/host.hh" #include "cpu/base_cpu.hh" @@ -61,11 +62,17 @@ class SyscallDesc { FuncPtr funcPtr; int flags; + enum Flags { + SuppressReturnValue = 1 + }; + SyscallDesc(const char *_name, FuncPtr _funcPtr, int _flags = 0) : name(_name), funcPtr(_funcPtr), flags(_flags) - {} + { + } - int doFunc(int num, Process *proc, ExecContext *xc) { + int doFunc(int num, Process *proc, ExecContext *xc) + { return (*funcPtr)(this, num, proc, xc); } }; @@ -75,7 +82,8 @@ class BaseBufferArg { public: - BaseBufferArg(Addr _addr, int _size) : addr(_addr), size(_size) { + BaseBufferArg(Addr _addr, int _size) : addr(_addr), size(_size) + { bufPtr = new uint8_t[size]; // clear out buffer: in case we only partially populate this, // and then do a copyOut(), we want to make sure we don't @@ -88,7 +96,8 @@ class BaseBufferArg { // // copy data into simulator space (read from target memory) // - virtual bool copyIn(FunctionalMemory *mem) { + virtual bool copyIn(FunctionalMemory *mem) + { mem->access(Read, addr, bufPtr, size); return true; // no EFAULT detection for now } @@ -96,7 +105,8 @@ class BaseBufferArg { // // copy data out of simulator space (write to target memory) // - virtual bool copyOut(FunctionalMemory *mem) { + virtual bool copyOut(FunctionalMemory *mem) + { mem->access(Write, addr, bufPtr, size); return true; // no EFAULT detection for now } @@ -154,7 +164,7 @@ setArg(ExecContext *xc, int i, IntReg val) static void -set_return_value(ExecContext *xc, IntReg return_value) +set_return_value(ExecContext *xc, int64_t return_value) { // check for error condition. Alpha syscall convention is to // indicate success/failure in reg a3 (r19) and put the @@ -194,60 +204,27 @@ int ioctlFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { - int fd = process->sim_fd(getArg(xc, 0)); + int fd = getArg(xc, 0); unsigned req = getArg(xc, 1); - switch (req) { - case OSF::TIOCGETP: { - // get tty parameters: the main use of this call is by - // isatty(), which really just wants to see whether it - // succeeds or returns ENOTTY to determine whether this is - // a terminal or not. This call is in turn used by the - // stdio library to determine whether to do line buffering - // or block buffering on a specific file descriptor. - TypedBufferArg<OSF::sgttyb> buf(getArg(xc, 2)); - - if (fd < 0) { - // bad file descriptor - return -EBADF; - } else if (0 <= fd < 3) { - // stdin/stdout/stderr: make it look like a terminal - // so we get line buffering & not block buffering - buf->sg_ispeed = 0xf; - buf->sg_ospeed = 0xf; - buf->sg_erase = 0x7f; - buf->sg_kill = 0x15; - buf->sg_flags = 0x18; - buf.copyOut(xc->mem); - return 0; - } else { - // any other file descriptor: assume it's a file or - // pipe and not a terminal - return -ENOTTY; - } - break; - } + DPRINTFR(SyscallVerbose, "ioctl(%d, 0x%x, ...)\n", fd, req); + if (fd < 0 || process->sim_fd(fd) < 0) { + // doesn't map to any simulator fd: not a valid target fd + return -EBADF; + } + + switch (req) { case OSF::TIOCISATTY: - if (fd < 0) { - // bad file descriptor - return -EBADF; - } else if (0 <= fd < 3) { - // stdin/stdout/stderr: make it look like a terminal - // so we get line buffering & not block buffering - return 0; - } else { - // any other file descriptor: assume it's a file or - // pipe and not a terminal - return -ENOTTY; - } - break; + case OSF::TIOCGETP: + case OSF::TIOCSETP: + case OSF::TIOCSETN: + case OSF::TIOCSETC: + case OSF::TIOCGETC: + return -ENOTTY; default: - cerr << "Unsupported ioctl call: ioctl(" - << fd << ", " << req << ", ...)" << endl; - abort(); - break; + fatal("Unsupported ioctl call: ioctl(%d, 0x%x, ...)\n", fd, req); } } @@ -421,6 +398,8 @@ fstatFunc(SyscallDesc *desc, int callnum, Process *process, { int fd = process->sim_fd(getArg(xc, 0)); + DPRINTFR(SyscallVerbose, "fstat(%d, ...)\n", fd); + if (fd < 0) return -EBADF; @@ -586,17 +565,179 @@ getpidFunc(SyscallDesc *desc, int callnum, Process *process, // Make up a PID. There's no interprocess communication in // fake_syscall mode, so there's no way for a process to know it's // not getting a unique value. + + // This is one of the funky syscalls that has two return values, + // with the second one (parent PID) going in r20. + xc->regs.intRegFile[20] = 99; return 100; } + int getuidFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) { - // Make up a UID. + // Make up a UID and EUID... it shouldn't matter, and we want the + // simulation to be deterministic. + + // EUID goes in r20. + xc->regs.intRegFile[20] = 100; // EUID + return 100; // UID +} + + +int +getgidFunc(SyscallDesc *desc, int callnum, Process *process, + ExecContext *xc) +{ + // Get current group ID. EGID goes in r20. + xc->regs.intRegFile[20] = 100; return 100; } + +int +setuidFunc(SyscallDesc *desc, int callnum, Process *process, + ExecContext *xc) +{ + // can't fathom why a benchmark would call this. + warn("Ignoring call to setuid(%d)\n", getArg(xc, 0)); + return 0; +} + + +int +fcntlFunc(SyscallDesc *desc, int callnum, Process *process, + ExecContext *xc) +{ + int fd = getArg(xc,0); + + if (fd < 0 || process->sim_fd(fd) < 0) + return -EBADF; + + int cmd = getArg(xc,1); + switch (cmd) { + case 0: // F_DUPFD + // if we really wanted to support this, we'd need to do it + // in the target fd space. + warn("fcntl(%d, F_DUPFD) not supported, error returned\n", fd); + return -EMFILE; + + case 1: // F_GETFD (get fd flags) + case 2: // F_SETFD (set fd flags) + case 3: // F_GETFL (get file flags) + case 4: // F_SETFL (set file flags) + // not sure if this is totally valid, but we'll pass it through + // to the underlying OS + warn("fcntl(%d, %d) passed through to host\n", fd, cmd); + return fcntl(process->sim_fd(fd), cmd); + // return 0; + + case 7: // F_GETLK (get lock) + case 8: // F_SETLK (set lock) + case 9: // F_SETLKW (set lock and wait) + // don't mess with file locking... just act like it's OK + warn("File lock call (fcntl(%d, %d)) ignored.\n", fd, cmd); + return 0; + + default: + warn("Unknown fcntl command %d\n", cmd); + return 0; + } +} + + +/// +/// @TODO this was stolen from SimpleScalar and needs to be rewritten. +/// + +/* returns size of DIRENT structure */ +#define OSF_DIRENT_SZ(STR) \ + (sizeof(uint32_t) + 2*sizeof(uint16_t) + (((strlen(STR) + 1) + 3)/4)*4) + /* was: (sizeof(word_t) + 2*sizeof(half_t) + strlen(STR) + 1) */ + +struct osf_dirent +{ + uint32_t d_ino; /* file number of entry */ + uint16_t d_reclen; /* length of this record */ + uint16_t d_namlen; /* length of string in d_name */ + char d_name[256]; /* DUMMY NAME LENGTH */ + /* the real maximum length is */ + /* returned by pathconf() */ + /* At this time, this MUST */ + /* be 256 -- the kernel */ + /* requires it */ +}; + + +int +getdirentriesFunc(SyscallDesc *desc, int callnum, Process *process, + ExecContext *xc) +{ + int i, cnt, osf_cnt; + struct dirent *p; + int32_t fd = process->sim_fd(getArg(xc,0)); + Addr osf_buf = getArg(xc,1); + char *buf; + int32_t osf_nbytes = getArg(xc,2); + Addr osf_pbase = getArg(xc,3); + Addr osf_base; + long base = 0; + + /* number of entries in simulated memory */ + if (!osf_nbytes) + warn("attempting to get 0 directory entries..."); + + /* allocate local memory, whatever fits */ + buf = (char*)calloc(1, osf_nbytes); + if (!buf) + fatal("out of virtual memory"); + + /* get directory entries */ + int64_t result = getdirentries((int)fd, buf, (size_t)osf_nbytes, &base); + + /* check for an error condition */ + if (result != (int64_t) -1) { + + /* anything to copy back? */ + if (result > 0) + { + /* copy all possible results to simulated space */ + for (i=0, cnt=0, osf_cnt=0, p=(struct dirent *)buf; + cnt < result && p->d_reclen > 0; + i++, cnt += p->d_reclen, p=(struct dirent *)(buf+cnt)) + { + struct osf_dirent osf_dirent; + + osf_dirent.d_ino = p->d_ino; + osf_dirent.d_namlen = strlen(p->d_name); + strcpy(osf_dirent.d_name, p->d_name); + osf_dirent.d_reclen = OSF_DIRENT_SZ(p->d_name); + + xc->mem->access(Write, osf_buf + osf_cnt, + &osf_dirent, OSF_DIRENT_SZ(p->d_name)); + + osf_cnt += OSF_DIRENT_SZ(p->d_name); + } + + if (osf_pbase != 0) + { + osf_base = (Addr)base; + + xc->mem->access(Write, osf_pbase, &osf_base, sizeof(osf_base)); + } + + /* update V0 to indicate translated read length */ + result = osf_cnt; + } + } + + free(buf); + + return result; +} + + int getrlimitFunc(SyscallDesc *desc, int callnum, Process *process, ExecContext *xc) @@ -704,9 +845,11 @@ sigreturnFunc(SyscallDesc *desc, int callnum, Process *process, sc.copyIn(xc->mem); - // restore state from sigcontext structure - regs->pc = sc->sc_pc; - regs->npc = regs->pc + sizeof(MachInst); + // Restore state from sigcontext structure. + // Note that we'll advance PC <- NPC before the end of the cycle, + // so we need to restore the desired PC into NPC. + // The current regs->pc will get clobbered. + regs->npc = sc->sc_pc; for (int i = 0; i < 31; ++i) { regs->intRegFile[i] = sc->sc_regs[i]; @@ -807,7 +950,7 @@ exitFunc(SyscallDesc *desc, int callnum, Process *process, SyscallDesc syscallDescs[] = { - /* 0 */ SyscallDesc("syscall (#0)", indirectSyscallFunc), + /* 0 */ SyscallDesc("syscall (#0)", indirectSyscallFunc, SyscallDesc::SuppressReturnValue), /* 1 */ SyscallDesc("exit", exitFunc), /* 2 */ SyscallDesc("fork", unimplementedFunc), /* 3 */ SyscallDesc("read", readFunc), @@ -830,7 +973,7 @@ SyscallDesc syscallDescs[] = { /* 20 */ SyscallDesc("getpid", getpidFunc), /* 21 */ SyscallDesc("mount", unimplementedFunc), /* 22 */ SyscallDesc("unmount", unimplementedFunc), - /* 23 */ SyscallDesc("setuid", unimplementedFunc), + /* 23 */ SyscallDesc("setuid", setuidFunc), /* 24 */ SyscallDesc("getuid", getuidFunc), /* 25 */ SyscallDesc("exec_with_loader", unimplementedFunc), /* 26 */ SyscallDesc("ptrace", unimplementedFunc), @@ -854,7 +997,7 @@ SyscallDesc syscallDescs[] = { /* 44 */ SyscallDesc("profil", unimplementedFunc), /* 45 */ SyscallDesc("open", openFunc), /* 46 */ SyscallDesc("obsolete osigaction", unimplementedFunc), - /* 47 */ SyscallDesc("getgid", unimplementedFunc), + /* 47 */ SyscallDesc("getgid", getgidFunc), /* 48 */ SyscallDesc("sigprocmask", ignoreFunc), /* 49 */ SyscallDesc("getlogin", unimplementedFunc), /* 50 */ SyscallDesc("setlogin", unimplementedFunc), @@ -899,7 +1042,7 @@ SyscallDesc syscallDescs[] = { /* 89 */ SyscallDesc("getdtablesize", unimplementedFunc), /* 90 */ SyscallDesc("dup2", unimplementedFunc), /* 91 */ SyscallDesc("pre_F64_fstat", unimplementedFunc), - /* 92 */ SyscallDesc("fcntl", unimplementedFunc), + /* 92 */ SyscallDesc("fcntl", fcntlFunc), /* 93 */ SyscallDesc("select", unimplementedFunc), /* 94 */ SyscallDesc("poll", unimplementedFunc), /* 95 */ SyscallDesc("fsync", unimplementedFunc), @@ -910,7 +1053,7 @@ SyscallDesc syscallDescs[] = { /* 100 */ SyscallDesc("getpriority", unimplementedFunc), /* 101 */ SyscallDesc("old_send", unimplementedFunc), /* 102 */ SyscallDesc("old_recv", unimplementedFunc), - /* 103 */ SyscallDesc("sigreturn", sigreturnFunc), + /* 103 */ SyscallDesc("sigreturn", sigreturnFunc, SyscallDesc::SuppressReturnValue), /* 104 */ SyscallDesc("bind", unimplementedFunc), /* 105 */ SyscallDesc("setsockopt", unimplementedFunc), /* 106 */ SyscallDesc("listen", unimplementedFunc), @@ -966,7 +1109,7 @@ SyscallDesc syscallDescs[] = { /* 156 */ SyscallDesc("sigaction", ignoreFunc), /* 157 */ SyscallDesc("sigwaitprim", unimplementedFunc), /* 158 */ SyscallDesc("nfssvc", unimplementedFunc), - /* 159 */ SyscallDesc("getdirentries", unimplementedFunc), + /* 159 */ SyscallDesc("getdirentries", getdirentriesFunc), /* 160 */ SyscallDesc("pre_F64_statfs", unimplementedFunc), /* 161 */ SyscallDesc("pre_F64_fstatfs", unimplementedFunc), /* 162 */ SyscallDesc("unknown #162", unimplementedFunc), @@ -1688,9 +1831,8 @@ const int Min_Syscall_Desc = -Max_Mach_Syscall_Desc; // helper function for invoking syscalls // static -int -doSyscall(int callnum, Process *process, - ExecContext *xc) +void +doSyscall(int callnum, Process *process, ExecContext *xc) { if (callnum < Min_Syscall_Desc || callnum > Max_Syscall_Desc) { cerr << "Syscall " << callnum << " out of range" << endl; @@ -1700,10 +1842,16 @@ doSyscall(int callnum, Process *process, SyscallDesc *desc = (callnum < 0) ? &machSyscallDescs[-callnum] : &syscallDescs[callnum]; - DCOUT(SyscallVerbose) << xc->cpu->name() << ": syscall " << desc->name - << " called @ " << curTick << endl; + DPRINTFR(SyscallVerbose, "%s: syscall %s called\n", + xc->cpu->name(), desc->name); + + int retval = desc->doFunc(callnum, process, xc); - return desc->doFunc(callnum, process, xc); + DPRINTFR(SyscallVerbose, "%s: syscall %s returns %d\n", + xc->cpu->name(), desc->name, retval); + + if (!((desc->flags & SyscallDesc::SuppressReturnValue) && retval == 0)) + set_return_value(xc, retval); } // @@ -1718,7 +1866,9 @@ indirectSyscallFunc(SyscallDesc *desc, int callnum, Process *process, for (int i = 0; i < 5; ++i) setArg(xc, i, getArg(xc, i+1)); - return doSyscall(new_callnum, process, xc); + doSyscall(new_callnum, process, xc); + + return 0; } @@ -1727,7 +1877,5 @@ fake_syscall(Process *process, ExecContext *xc) { int64_t callnum = xc->regs.intRegFile[ReturnValueReg]; - int retval = doSyscall(callnum, process, xc); - - set_return_value(xc, retval); + doSyscall(callnum, process, xc); } diff --git a/arch/alpha/isa_desc b/arch/alpha/isa_desc index 4364bae34..e3b8cf01b 100644 --- a/arch/alpha/isa_desc +++ b/arch/alpha/isa_desc @@ -561,13 +561,19 @@ declare {{ { std::string mnem_str(mnemonic); - mnem_str += ((_destRegIdx[0] >= FP_Base_DepTag) - ? fpTrappingModeSuffix[trappingMode] - : intTrappingModeSuffix[trappingMode]); - mnem_str += roundingModeSuffix[roundingMode]; +#ifndef SS_COMPATIBLE_DISASSEMBLY + std::string suffix(""); + suffix += ((_destRegIdx[0] >= FP_Base_DepTag) + ? fpTrappingModeSuffix[trappingMode] + : intTrappingModeSuffix[trappingMode]); + suffix += roundingModeSuffix[roundingMode]; + + if (suffix != "") { + mnem_str = csprintf("%s/%s", mnemonic, suffix); + } +#endif std::stringstream ss; - ccprintf(ss, "%-10s ", mnem_str.c_str()); // just print the first two source regs... if there's @@ -1791,8 +1797,10 @@ decode OPCODE default Unknown::unknown() { format LoadOrPrefetch { 0x28: ldl({{ EA = Rb + disp; }}, {{ Ra.sl = Mem.sl; }}); 0x29: ldq({{ EA = Rb + disp; }}, {{ Ra.uq = Mem.uq; }}, EVICT_NEXT); + // IsFloating flag on lds gets the prefetch to disassemble + // using f31 instead of r31... funcitonally it's unnecessary 0x22: lds({{ EA = Rb + disp; }}, {{ Fa.uq = s_to_t(Mem.ul); }}, - PF_EXCLUSIVE); + PF_EXCLUSIVE, IsFloating); } format Store { diff --git a/base/misc.cc b/base/misc.cc index e798dd656..8190caddd 100644 --- a/base/misc.cc +++ b/base/misc.cc @@ -42,7 +42,8 @@ void __panic(const string &format, cp::ArgList &args, const char *func, const char *file, int line) { - string fmt = "panic: " + format + " [%s:%s, line %d]\n"; + string fmt = "panic: " + format + " @ cycle %d\n[%s:%s, line %d]\n"; + args.append(curTick); args.append(func); args.append(file); args.append(line); @@ -62,13 +63,13 @@ void __fatal(const string &format, cp::ArgList &args, const char *func, const char *file, int line) { - string fmt = "fatal: " + format + " [%s:%s, line %d]\n" - "\n%d\nMemory Usage: %ld KBytes\n"; + string fmt = "fatal: " + format + " @ cycle %d\n[%s:%s, line %d]\n" + "Memory Usage: %ld KBytes\n"; + args.append(curTick); args.append(func); args.append(file); args.append(line); - args.append(curTick); args.append(memUsage()); args.dump(cerr, fmt); @@ -83,7 +84,8 @@ __warn(const string &format, cp::ArgList &args, const char *func, { string fmt = "warn: " + format; #ifdef VERBOSE_WARN - fmt += " [%s:%s, line %d]\n"; + fmt += " @ cycle %d\n[%s:%s, line %d]\n"; + args.append(curTick); args.append(func); args.append(file); args.append(line); diff --git a/base/statistics.cc b/base/statistics.cc index 14bdb32f6..5c1844327 100644 --- a/base/statistics.cc +++ b/base/statistics.cc @@ -161,6 +161,7 @@ void Database::dump(ostream &stream) { +#ifndef FS_MEASURE list_t::iterator i = printStats.begin(); list_t::iterator end = printStats.end(); while (i != end) { @@ -169,6 +170,7 @@ Database::dump(ostream &stream) binnedStats.push_back(stat); ++i; } +#endif //FS_MEASURE list<GenBin *>::iterator j = bins.begin(); list<GenBin *>::iterator bins_end=bins.end(); @@ -183,8 +185,13 @@ Database::dump(ostream &stream) panic("a binned stat not found in names map!"); ccprintf(stream,"---%s Bin------------\n", (*iter).second); +#ifdef FS_MEASURE + list_t::iterator i = printStats.begin(); + list_t::iterator end = printStats.end(); +#else list_t::iterator i = binnedStats.begin(); list_t::iterator end = binnedStats.end(); +#endif while (i != end) { Stat *stat = *i; if (stat->dodisplay()) @@ -194,9 +201,16 @@ Database::dump(ostream &stream) ++j; ccprintf(stream, "---------------------------------\n"); } +#ifndef FS_MEASURE ccprintf(stream, "**************ALL STATS************\n"); +#endif } +/** + * get bin totals working, then print the stat here (as total), even if + * its' binned. (this is only for the case you selectively bin a few stats + */ +#ifndef FS_MEASURE list_t::iterator k = printStats.begin(); list_t::iterator endprint = printStats.end(); while (k != endprint) { @@ -205,6 +219,7 @@ Database::dump(ostream &stream) stat->display(stream); ++k; } +#endif } StatData * diff --git a/base/statistics.hh b/base/statistics.hh index 2fe6988b0..aa3489727 100644 --- a/base/statistics.hh +++ b/base/statistics.hh @@ -60,6 +60,9 @@ #include <math.h> #include "sim/host.hh" +#ifdef FS_MEASURE +#include "base/trace.hh" +#endif // // Un-comment this to enable weirdo-stat debugging // @@ -2167,6 +2170,7 @@ class GenBin : public Detail::BinBase virtual ~GenBin() {}; virtual void activate() = 0; + virtual std::string name() const = 0; void regBin(GenBin *bin, std::string name); }; @@ -2198,7 +2202,6 @@ struct StatBin : public GenBin // That one is for the last trailing flags byte. offset() += (size + 1 + mask) & ~mask; - return off; } @@ -2212,7 +2215,12 @@ struct StatBin : public GenBin return Detail::BinBase::memory() + off; } - virtual void activate() { setCurBin(this); } + virtual void activate() { + setCurBin(this); +#ifdef FS_MEASURE + DPRINTF(TCPIP, "activating %s Bin\n", name()); +#endif + } static void activate(StatBin &bin) { setCurBin(&bin); } class BinBase @@ -2426,7 +2434,11 @@ struct NoBin * is NoBin, nothing is binned. If it is MainBin (or whatever *Bin), then all stats are binned * under that Bin. */ +#ifdef FS_MEASURE +typedef MainBin DefaultBin; +#else typedef NoBin DefaultBin; +#endif /** * This is a simple scalar statistic, like a counter. diff --git a/cpu/exec_context.cc b/cpu/exec_context.cc index 195c9daad..92144bd93 100644 --- a/cpu/exec_context.cc +++ b/cpu/exec_context.cc @@ -48,6 +48,9 @@ ExecContext::ExecContext(BaseCPU *_cpu, int _thread_num, System *_sys, kernelStats(this, _cpu), cpu(_cpu), thread_num(_thread_num), cpu_id(-1), mem(_mem), itb(_itb), dtb(_dtb), system(_sys), memCtrl(_sys->memCtrl), physmem(_sys->physmem), +#ifdef FS_MEASURE + swCtx(NULL), +#endif func_exe_insn(0), storeCondFailures(0) { memset(®s, 0, sizeof(RegFile)); diff --git a/cpu/exec_context.hh b/cpu/exec_context.hh index e008e3e13..274a3778b 100644 --- a/cpu/exec_context.hh +++ b/cpu/exec_context.hh @@ -46,6 +46,10 @@ class MemoryController; #include "kern/tru64/kernel_stats.hh" #include "sim/system.hh" +#ifdef FS_MEASURE +#include "sim/sw_context.hh" +#endif + #else // !FULL_SYSTEM #include "sim/prog.hh" @@ -122,6 +126,10 @@ class ExecContext MemoryController *memCtrl; PhysicalMemory *physmem; +#ifdef FS_MEASURE + SWContext *swCtx; +#endif + #else Process *process; diff --git a/cpu/exetrace.cc b/cpu/exetrace.cc index c350288bc..ce6b0c544 100644 --- a/cpu/exetrace.cc +++ b/cpu/exetrace.cc @@ -74,11 +74,11 @@ Trace::InstRecord::dump(ostream &outs) // There's a bug in gcc 2.x library that prevents setw() // from working properly on strings string mc(staticInst->disassemble(PC, debugSymbolTable)); - while (mc.length() < 25) + while (mc.length() < 26) mc += " "; outs << mc; #else - outs << setw(25) << staticInst->disassemble(PC, debugSymbolTable); + outs << setw(26) << left << staticInst->disassemble(PC, debugSymbolTable); #endif outs << " : "; diff --git a/cpu/simple_cpu/simple_cpu.cc b/cpu/simple_cpu/simple_cpu.cc index 60d704604..814902390 100644 --- a/cpu/simple_cpu/simple_cpu.cc +++ b/cpu/simple_cpu/simple_cpu.cc @@ -627,7 +627,32 @@ SimpleCPU::tick() xc->func_exe_insn++; fault = si->execute(this, xc, traceData); - +#ifdef FS_MEASURE + if (!(xc->misspeculating()) && (xc->system->bin)) { + SWContext *ctx = xc->swCtx; + if (ctx && !ctx->callStack.empty()) { + if (si->isCall()) { + ctx->calls++; + } + if (si->isReturn()) { + if (ctx->calls == 0) { + fnCall *top = ctx->callStack.top(); + DPRINTF(TCPIP, "Removing %s from callstack.\n", top->name); + delete top; + ctx->callStack.pop(); + if (ctx->callStack.empty()) + xc->system->nonPath->activate(); + else + ctx->callStack.top()->myBin->activate(); + + xc->system->dumpState(xc); + } else { + ctx->calls--; + } + } + } + } +#endif if (si->isMemRef()) { numMemRefs++; } diff --git a/cpu/simple_cpu/simple_cpu.hh b/cpu/simple_cpu/simple_cpu.hh index 61c9143ba..6ad831218 100644 --- a/cpu/simple_cpu/simple_cpu.hh +++ b/cpu/simple_cpu/simple_cpu.hh @@ -216,7 +216,7 @@ class SimpleCPU : public BaseCPU assert(old_status == Idle || old_status == DcacheMissStall || old_status == IcacheMissComplete); - if (old_status == Idle) + if (old_status == Idle && curTick != 0) idleCycles += curTick - last_idle; if (tickEvent.squashed()) diff --git a/dev/etherlink.cc b/dev/etherlink.cc index 6fb7187d2..c042cac34 100644 --- a/dev/etherlink.cc +++ b/dev/etherlink.cc @@ -125,7 +125,7 @@ BEGIN_DECLARE_SIM_OBJECT_PARAMS(EtherLink) SimObjectParam<EtherInt *> interface1; SimObjectParam<EtherInt *> interface2; - Param<int> link_speed; + Param<Tick> link_speed; SimObjectParam<EtherDump *> packet_dump; END_DECLARE_SIM_OBJECT_PARAMS(EtherLink) diff --git a/kern/tru64/tru64_events.cc b/kern/tru64/tru64_events.cc index 538246333..bb6588e62 100644 --- a/kern/tru64/tru64_events.cc +++ b/kern/tru64/tru64_events.cc @@ -36,6 +36,11 @@ #include "mem/functional_mem/memory_control.hh" #include "targetarch/arguments.hh" +#ifdef FS_MEASURE +#include "sim/system.hh" +#include "sim/sw_context.hh" +#endif + void SkipFuncEvent::process(ExecContext *xc) { @@ -105,3 +110,48 @@ DumpMbufEvent::process(ExecContext *xc) } } +#ifdef FS_MEASURE +FnEvent::FnEvent(PCEventQueue *q, const std::string & desc, System *system) + : PCEvent(q, desc), _name(desc) +{ + myBin = system->getBin(desc); + assert(myBin); +} + +void +FnEvent::process(ExecContext *xc) +{ + if (xc->misspeculating()) + return; + assert(xc->system->bin && "FnEvent must be in a binned system"); + SWContext *ctx = xc->swCtx; + DPRINTF(TCPIP, "%s: %s Event!!!\n", xc->system->name(), description); + + if (ctx && !ctx->callStack.empty()) { + fnCall *last = ctx->callStack.top(); + if (!xc->system->findCaller(myname(), last->name)) { + // assert(!xc->system->findCaller(myname(), "") && + // "should not have head of path in middle of stack!"); + return; + } + ctx->calls--; + } else { + if (!xc->system->findCaller(myname(), "")) { + return; + } + if (!ctx) { + DPRINTF(TCPIP, "creating new context for %s\n", myname()); + ctx = new SWContext; + xc->swCtx = ctx; + } + } + DPRINTF(TCPIP, "adding fn %s to context\n", myname()); + fnCall *call = new fnCall; + call->myBin = myBin; + call->name = myname(); + ctx->callStack.push(call); + myBin->activate(); + xc->system->fnCalls++; + xc->system->dumpState(xc); +} +#endif //FS_MEASURE diff --git a/kern/tru64/tru64_events.hh b/kern/tru64/tru64_events.hh index d41f82f5b..a8f0eb865 100644 --- a/kern/tru64/tru64_events.hh +++ b/kern/tru64/tru64_events.hh @@ -35,6 +35,10 @@ class ExecContext; +#ifdef FS_MEASURE +class System; +#endif + class SkipFuncEvent : public PCEvent { public: @@ -78,4 +82,17 @@ class DumpMbufEvent : public PCEvent virtual void process(ExecContext *xc); }; +#ifdef FS_MEASURE +class FnEvent : public PCEvent +{ + public: + FnEvent(PCEventQueue *q, const std::string &desc, System *system); + virtual void process(ExecContext *xc); + std::string myname() const { return _name; } + + private: + std::string _name; + Statistics::GenBin *myBin; +}; +#endif //FS_MEASURE #endif // __TRU64_EVENTS_HH__ diff --git a/kern/tru64/tru64_system.cc b/kern/tru64/tru64_system.cc index a7940ed1f..6f4a0b169 100644 --- a/kern/tru64/tru64_system.cc +++ b/kern/tru64/tru64_system.cc @@ -41,13 +41,17 @@ #include "targetarch/isa_traits.hh" #include "targetarch/vtophys.hh" +//un-comment this to see the state of call stack when it changes. +//#define SW_DEBUG + using namespace std; Tru64System::Tru64System(const string _name, const uint64_t _init_param, MemoryController *_memCtrl, PhysicalMemory *_physmem, const string &kernel_path, const string &console_path, - const string &palcode, const string &boot_osflags) - : System(_name, _init_param, _memCtrl, _physmem) + const string &palcode, const string &boot_osflags, + const bool _bin) + : System(_name, _init_param, _memCtrl, _physmem, _bin), bin(_bin) { kernelSymtab = new SymbolTable; consoleSymtab = new SymbolTable; @@ -88,6 +92,88 @@ Tru64System::Tru64System(const string _name, const uint64_t _init_param, DPRINTF(Loader, "Kernel loaded...\n"); +#ifdef FS_MEASURE + //INSTRUMENTATION CODEGEN BEGIN ONE + if (bin == true) { + esIntrBin = new Statistics::MainBin(name() + " es_intr"); + fnBins.insert(make_pair("es_intr", esIntrBin)); + + esRxeofBin = new Statistics::MainBin(name() + " es_rxeof"); + fnBins.insert(make_pair("es_rxeof", esRxeofBin)); + + esNewbufBin = new Statistics::MainBin(name() + " es_newbuf"); + fnBins.insert(make_pair("es_newbuf", esNewbufBin)); + + esDmaLoadBin = new Statistics::MainBin(name() + " es_dma_load"); + fnBins.insert(make_pair("es_dma_load", esDmaLoadBin)); + + dmaMapLoadBin = new Statistics::MainBin(name() + " dma_map_load"); + fnBins.insert(make_pair("dma_map_load", dmaMapLoadBin)); + + etherInputBin = new Statistics::MainBin(name() + " ether_input"); + fnBins.insert(make_pair("ether_input", etherInputBin)); + + netisrInputBin = new Statistics::MainBin(name() + " netisr_input"); + fnBins.insert(make_pair("netisr_input", netisrInputBin)); + + schednetisrIsrBin = new Statistics::MainBin(name() + " schednetisr_isr"); + fnBins.insert(make_pair("schednetisr_isr", schednetisrIsrBin)); + + ipintrBin = new Statistics::MainBin(name() + " ipintr"); + fnBins.insert(make_pair("ipintr", ipintrBin)); + + ipDooptionsBin = new Statistics::MainBin(name() + " ip_dooptions"); + fnBins.insert(make_pair("ip_dooptions", ipDooptionsBin)); + + ipReassBin = new Statistics::MainBin(name() + " ip_reass"); + fnBins.insert(make_pair("ip_reass", ipReassBin)); + + tcpInputBin = new Statistics::MainBin(name() + " tcp_input"); + fnBins.insert(make_pair("tcp_input", tcpInputBin)); + + sbappendBin = new Statistics::MainBin(name() + " sbappend"); + fnBins.insert(make_pair("sbappend", sbappendBin)); + + orecvBin = new Statistics::MainBin(name() + " orecv"); + fnBins.insert(make_pair("orecv", orecvBin)); + + recvitBin = new Statistics::MainBin(name() + " recvit"); + fnBins.insert(make_pair("recvit", recvitBin)); + + soreceiveBin = new Statistics::MainBin(name() + " soreceive"); + fnBins.insert(make_pair("soreceive", soreceiveBin)); + + osendBin = new Statistics::MainBin(name() + " osend"); + fnBins.insert(make_pair("osend", osendBin)); + + senditBin = new Statistics::MainBin(name() + " sendit"); + fnBins.insert(make_pair("sendit", senditBin)); + + sosendBin = new Statistics::MainBin(name() + " sosend"); + fnBins.insert(make_pair("sosend", sosendBin)); + + tcpOutputBin = new Statistics::MainBin(name() + " tcp_output"); + fnBins.insert(make_pair("tcp_output", tcpOutputBin)); + + ipOutputBin = new Statistics::MainBin(name() + " ip_output"); + fnBins.insert(make_pair("ip_output", ipOutputBin)); + + etherOutputBin = new Statistics::MainBin(name() + " ether_output"); + fnBins.insert(make_pair("ether_output", etherOutputBin)); + + esStartBin = new Statistics::MainBin(name() + " es_start"); + fnBins.insert(make_pair("es_start", esStartBin)); + + esTransmitBin = new Statistics::MainBin(name() + " es_transmit"); + fnBins.insert(make_pair("es_transmit", esTransmitBin)); + + esTxeofBin = new Statistics::MainBin(name() + " es_txeof"); + fnBins.insert(make_pair("es_txeof", esTxeofBin)); + + } + //INSTRUMENTATION CODEGEN END +#endif //FS_MEASURE + kernelPanicEvent = new BreakPCEvent(&pcEventQueue, "kernel panic"); consolePanicEvent = new BreakPCEvent(&pcEventQueue, "console panic"); badaddrEvent = new BadAddrEvent(&pcEventQueue, "badaddr"); @@ -102,6 +188,38 @@ Tru64System::Tru64System(const string _name, const uint64_t _init_param, "debug_printfr", true); dumpMbufEvent = new DumpMbufEvent(&pcEventQueue, "dump_mbuf"); +#ifdef FS_MEASURE + //INSTRUMENTATION CODEGEN BEGIN TWO + if (bin == true) { + esIntrEvent = new FnEvent(&pcEventQueue, "es_intr", this); + esRxeofEvent = new FnEvent(&pcEventQueue, "es_rxeof", this); + esNewbufEvent = new FnEvent(&pcEventQueue, "es_newbuf", this); + esDmaLoadEvent = new FnEvent(&pcEventQueue, "es_dma_load", this); + dmaMapLoadEvent = new FnEvent(&pcEventQueue, "dma_map_load", this); + etherInputEvent = new FnEvent(&pcEventQueue, "ether_input", this); + netisrInputEvent = new FnEvent(&pcEventQueue, "netisr_input", this); + schednetisrIsrEvent = new FnEvent(&pcEventQueue, "schednetisr_isr", this); + ipintrEvent = new FnEvent(&pcEventQueue, "ipintr", this); + ipDooptionsEvent = new FnEvent(&pcEventQueue, "ip_dooptions", this); + ipReassEvent = new FnEvent(&pcEventQueue, "ip_reass", this); + tcpInputEvent = new FnEvent(&pcEventQueue, "tcp_input", this); + sbappendEvent = new FnEvent(&pcEventQueue, "sbappend", this); + orecvEvent = new FnEvent(&pcEventQueue, "orecv", this); + recvitEvent = new FnEvent(&pcEventQueue, "recvit", this); + soreceiveEvent = new FnEvent(&pcEventQueue, "soreceive", this); + osendEvent = new FnEvent(&pcEventQueue, "osend", this); + senditEvent = new FnEvent(&pcEventQueue, "sendit", this); + sosendEvent = new FnEvent(&pcEventQueue, "sosend", this); + tcpOutputEvent = new FnEvent(&pcEventQueue, "tcp_output", this); + ipOutputEvent = new FnEvent(&pcEventQueue, "ip_output", this); + etherOutputEvent = new FnEvent(&pcEventQueue, "ether_output", this); + esStartEvent = new FnEvent(&pcEventQueue, "es_start", this); + esTransmitEvent = new FnEvent(&pcEventQueue, "es_transmit", this); + esTxeofEvent = new FnEvent(&pcEventQueue, "es_txeof", this); + } + //INSTRUMENTATION CODEGEN END +#endif //FS_MEASURE + Addr addr = 0; if (kernelSymtab->findAddress("enable_async_printf", addr)) { Addr paddr = vtophys(physmem, addr); @@ -152,6 +270,177 @@ Tru64System::Tru64System(const string _name, const uint64_t _init_param, if (kernelSymtab->findAddress("m5_dump_mbuf", addr)) dumpMbufEvent->schedule(addr); #endif + +#ifdef FS_MEASURE + //INSTRUMENTATION CODEGEN BEGIN THREE + if (bin == true) { + if (kernelSymtab->findAddress("es_intr", addr)) + esIntrEvent->schedule(addr); + else + panic("could not find kernel symbol \'es_intr\'"); + + if (kernelSymtab->findAddress("es_rxeof", addr)) + esRxeofEvent->schedule(addr); + else + panic("could not find kernel symbol \'es_rxeof\'"); + + if (kernelSymtab->findAddress("es_newbuf", addr)) + esNewbufEvent->schedule(addr); + else + panic("could not find kernel symbol \'es_newbuf\'"); + + if (kernelSymtab->findAddress("es_dma_load", addr)) + esDmaLoadEvent->schedule(addr); + else + panic("could not find kernel symbol \'es_dma_load\'"); + + if (kernelSymtab->findAddress("dma_map_load", addr)) + dmaMapLoadEvent->schedule(addr); + else + panic("could not find kernel symbol \'dma_map_load\'"); + + if (kernelSymtab->findAddress("ether_input", addr)) + etherInputEvent->schedule(addr); + else + panic("could not find kernel symbol \'ether_input\'"); + + if (kernelSymtab->findAddress("netisr_input", addr)) + netisrInputEvent->schedule(addr); + else + panic("could not find kernel symbol \'netisr_input\'"); + + if (kernelSymtab->findAddress("schednetisr_isr", addr)) + schednetisrIsrEvent->schedule(addr); + else + panic("could not find kernel symbol \'schednetisr_isr\'"); + + if (kernelSymtab->findAddress("ipintr", addr)) + ipintrEvent->schedule(addr); + else + panic("could not find kernel symbol \'ipintr\'"); + + if (kernelSymtab->findAddress("ip_dooptions", addr)) + ipDooptionsEvent->schedule(addr); + else + panic("could not find kernel symbol \'ip_dooptions\'"); + + if (kernelSymtab->findAddress("ip_reass", addr)) + ipReassEvent->schedule(addr); + else + panic("could not find kernel symbol \'ip_reass\'"); + + if (kernelSymtab->findAddress("tcp_input", addr)) + tcpInputEvent->schedule(addr); + else + panic("could not find kernel symbol \'tcp_input\'"); + + if (kernelSymtab->findAddress("sbappend", addr)) + sbappendEvent->schedule(addr); + else + panic("could not find kernel symbol \'sbappend\'"); + + if (kernelSymtab->findAddress("orecv", addr)) + orecvEvent->schedule(addr); + else + panic("could not find kernel symbol \'orecv\'"); + + if (kernelSymtab->findAddress("recvit", addr)) + recvitEvent->schedule(addr); + else + panic("could not find kernel symbol \'recvit\'"); + + if (kernelSymtab->findAddress("soreceive", addr)) + soreceiveEvent->schedule(addr); + else + panic("could not find kernel symbol \'soreceive\'"); + + if (kernelSymtab->findAddress("osend", addr)) + osendEvent->schedule(addr); + else + panic("could not find kernel symbol \'osend\'"); + + if (kernelSymtab->findAddress("sendit", addr)) + senditEvent->schedule(addr); + else + panic("could not find kernel symbol \'sendit\'"); + + if (kernelSymtab->findAddress("sosend", addr)) + sosendEvent->schedule(addr); + else + panic("could not find kernel symbol \'sosend\'"); + + if (kernelSymtab->findAddress("tcp_output", addr)) + tcpOutputEvent->schedule(addr); + else + panic("could not find kernel symbol \'tcp_output\'"); + + if (kernelSymtab->findAddress("ip_output", addr)) + ipOutputEvent->schedule(addr); + else + panic("could not find kernel symbol \'ip_output\'"); + + if (kernelSymtab->findAddress("ether_output", addr)) + etherOutputEvent->schedule(addr); + else + panic("could not find kernel symbol \'ether_output\'"); + + if (kernelSymtab->findAddress("es_start", addr)) + esStartEvent->schedule(addr); + else + panic("could not find kernel symbol \'es_start\'"); + + if (kernelSymtab->findAddress("es_transmit", addr)) + esTransmitEvent->schedule(addr); + else + panic("could not find kernel symbol \'es_transmit\'"); + + if (kernelSymtab->findAddress("es_txeof", addr)) + esTxeofEvent->schedule(addr); + else + panic("could not find kernel symbol \'es_txeof\'"); + + } + //INSTRUMENTATION CODEGEN END + if (bin == true) { + fnCalls + .name(name() + ":fnCalls") + .desc("all fn calls being tracked") + ; + + populateMap("es_intr", ""); + populateMap("es_rxeof", "es_intr"); + populateMap("es_newbuf", "es_rxeof"); + populateMap("es_dma_load", "es_newbuf"); + populateMap("dma_map_load", "es_dma_load"); + populateMap("ether_input", "es_rxeof"); + populateMap("netisr_input", "ether_input"); + populateMap("schednetisr_isr", "netisr_input"); + + populateMap("ipintr", ""); + populateMap("ip_dooptions", "ipintr"); + populateMap("ip_reass", "ipintr"); + populateMap("tcp_input", "ipintr"); + populateMap("sbappend", "tcp_input"); + + populateMap("read", ""); + populateMap("orecv", ""); + populateMap("recvit", "read"); + populateMap("recvit", "orecv"); + populateMap("soreceive", "recvit"); + + populateMap("write", ""); + populateMap("sendit", "write"); + populateMap("sosend", "sendit"); + + populateMap("tcp_output", ""); + populateMap("ip_output", "tcp_output"); + populateMap("ether_output", "ip_output"); + populateMap("es_start", "ether_output"); + populateMap("es_transmit", "es_start"); + + populateMap("es_txeof", "es_intr"); + } +#endif //FS_MEASURE } Tru64System::~Tru64System() @@ -172,6 +461,37 @@ Tru64System::~Tru64System() delete debugPrintfrEvent; delete dumpMbufEvent; +#ifdef FS_MEASURE + //INSTRUMENTATION CODEGEN BEGIN FOUR + if (bin == true) { + delete esIntrEvent; + delete esRxeofEvent; + delete esNewbufEvent; + delete esDmaLoadEvent; + delete dmaMapLoadEvent; + delete etherInputEvent; + delete netisrInputEvent; + delete schednetisrIsrEvent; + delete ipintrEvent; + delete ipDooptionsEvent; + delete ipReassEvent; + delete tcpInputEvent; + delete sbappendEvent; + delete orecvEvent; + delete recvitEvent; + delete soreceiveEvent; + delete osendEvent; + delete senditEvent; + delete sosendEvent; + delete tcpOutputEvent; + delete ipOutputEvent; + delete etherOutputEvent; + delete esStartEvent; + delete esTransmitEvent; + delete esTxeofEvent; + } + //INSTRUMENTATION CODEGEN END +#endif //FS_MEASURE } int @@ -210,8 +530,53 @@ Tru64System::breakpoint() return remoteGDB[0]->trap(ALPHA_KENTRY_IF); } +#ifdef FS_MEASURE +void +Tru64System::populateMap(std::string callee, std::string caller) +{ + multimap<const string, string>::const_iterator i; + i = callerMap.insert(make_pair(callee, caller)); + assert(i != callerMap.end() && "should not fail populating callerMap"); +} + +bool +Tru64System::findCaller(std::string callee, std::string caller) const +{ + typedef multimap<const std::string, std::string>::const_iterator iter; + pair<iter, iter> range; + + range = callerMap.equal_range(callee); + for (iter i = range.first; i != range.second; ++i) { + if ((*i).second == caller) + return true; + } + return false; +} + +void +Tru64System::dumpState(ExecContext *xc) const +{ +#ifndef SW_DEBUG + return; +#endif + if (xc->swCtx) { + stack<fnCall *> copy(xc->swCtx->callStack); + if (copy.empty()) + return; + cprintf("xc->swCtx:\n"); + fnCall *top; + cprintf("|| call: %d\n",xc->swCtx->calls); + for (top = copy.top(); !copy.empty(); copy.pop() ) { + top = copy.top(); + cprintf("|| %13s : %s \n", top->name, top->myBin->name()); + } + } +} +#endif //FS_MEASURE + BEGIN_DECLARE_SIM_OBJECT_PARAMS(Tru64System) + Param<bool> bin; SimObjectParam<MemoryController *> mem_ctl; SimObjectParam<PhysicalMemory *> physmem; Param<uint64_t> init_param; @@ -225,6 +590,7 @@ END_DECLARE_SIM_OBJECT_PARAMS(Tru64System) BEGIN_INIT_SIM_OBJECT_PARAMS(Tru64System) + INIT_PARAM_DFLT(bin, "is this system to be binned", false), INIT_PARAM(mem_ctl, "memory controller"), INIT_PARAM(physmem, "phsyical memory"), INIT_PARAM_DFLT(init_param, "numerical value to pass into simulator", 0), @@ -232,7 +598,8 @@ BEGIN_INIT_SIM_OBJECT_PARAMS(Tru64System) INIT_PARAM(console_code, "file that contains the console code"), INIT_PARAM(pal_code, "file that contains palcode"), INIT_PARAM_DFLT(boot_osflags, "flags to pass to the kernel during boot", - "a") + "a") + END_INIT_SIM_OBJECT_PARAMS(Tru64System) @@ -240,7 +607,7 @@ CREATE_SIM_OBJECT(Tru64System) { Tru64System *sys = new Tru64System(getInstanceName(), init_param, mem_ctl, physmem, kernel_code, console_code, - pal_code, boot_osflags); + pal_code, boot_osflags, bin); return sys; } diff --git a/kern/tru64/tru64_system.hh b/kern/tru64/tru64_system.hh index e0d2bedf7..638fabf1d 100644 --- a/kern/tru64/tru64_system.hh +++ b/kern/tru64/tru64_system.hh @@ -34,6 +34,10 @@ #include "sim/system.hh" #include "targetarch/isa_traits.hh" +#ifdef FS_MEASURE +#include <map> +#endif + class ExecContext; class EcoffObject; class SymbolTable; @@ -44,7 +48,9 @@ class SkipFuncEvent; class PrintfEvent; class DebugPrintfEvent; class DumpMbufEvent; - +#ifdef FS_MEASURE +class FnEvent; +#endif class AlphaArguments; class Tru64System : public System @@ -56,6 +62,36 @@ class Tru64System : public System SymbolTable *kernelSymtab; SymbolTable *consoleSymtab; +#ifdef FS_MEASURE + //INSTRUMENTATION CODEGEN BEGIN ONE + Statistics::MainBin *esIntrBin; + Statistics::MainBin *esRxeofBin; + Statistics::MainBin *esNewbufBin; + Statistics::MainBin *esDmaLoadBin; + Statistics::MainBin *dmaMapLoadBin; + Statistics::MainBin *etherInputBin; + Statistics::MainBin *netisrInputBin; + Statistics::MainBin *schednetisrIsrBin; + Statistics::MainBin *ipintrBin; + Statistics::MainBin *ipDooptionsBin; + Statistics::MainBin *ipReassBin; + Statistics::MainBin *tcpInputBin; + Statistics::MainBin *sbappendBin; + Statistics::MainBin *orecvBin; + Statistics::MainBin *recvitBin; + Statistics::MainBin *soreceiveBin; + Statistics::MainBin *osendBin; + Statistics::MainBin *senditBin; + Statistics::MainBin *sosendBin; + Statistics::MainBin *tcpOutputBin; + Statistics::MainBin *ipOutputBin; + Statistics::MainBin *etherOutputBin; + Statistics::MainBin *esStartBin; + Statistics::MainBin *esTransmitBin; + Statistics::MainBin *esTxeofBin; + //INSTRUMENTATION CODEGEN END +#endif //FS_MEASURE + BreakPCEvent *kernelPanicEvent; BreakPCEvent *consolePanicEvent; BadAddrEvent *badaddrEvent; @@ -65,12 +101,47 @@ class Tru64System : public System DebugPrintfEvent *debugPrintfEvent; DebugPrintfEvent *debugPrintfrEvent; DumpMbufEvent *dumpMbufEvent; +#ifdef FS_MEASURE + //INSTRUMENTATION CODEGEN BEGIN TWO + FnEvent *esIntrEvent; + FnEvent *esRxeofEvent; + FnEvent *esNewbufEvent; + FnEvent *esDmaLoadEvent; + FnEvent *dmaMapLoadEvent; + FnEvent *etherInputEvent; + FnEvent *netisrInputEvent; + FnEvent *schednetisrIsrEvent; + FnEvent *ipintrEvent; + FnEvent *ipDooptionsEvent; + FnEvent *ipReassEvent; + FnEvent *tcpInputEvent; + FnEvent *sbappendEvent; + FnEvent *orecvEvent; + FnEvent *recvitEvent; + FnEvent *soreceiveEvent; + FnEvent *osendEvent; + FnEvent *senditEvent; + FnEvent *sosendEvent; + FnEvent *tcpOutputEvent; + FnEvent *ipOutputEvent; + FnEvent *etherOutputEvent; + FnEvent *esStartEvent; + FnEvent *esTransmitEvent; + FnEvent *esTxeofEvent; + //INSTRUMENTATION CODEGEN END +#endif //FS_MEASURE private: Addr kernelStart; Addr kernelEnd; Addr kernelEntry; + bool bin; + +#ifdef FS_MEASURE + std::multimap<const std::string, std::string> callerMap; + void populateMap(std::string caller, std::string callee); +#endif public: std::vector<RemoteGDB *> remoteGDB; @@ -84,7 +155,8 @@ class Tru64System : public System const std::string &kernel_path, const std::string &console_path, const std::string &palcode, - const std::string &boot_osflags); + const std::string &boot_osflags, + const bool _bin); ~Tru64System(); int registerExecContext(ExecContext *xc); @@ -97,6 +169,11 @@ class Tru64System : public System static void Printf(AlphaArguments args); static void DumpMbuf(AlphaArguments args); + +#ifdef FS_MEASURE + bool findCaller(std::string callee, std::string caller) const; + void dumpState(ExecContext *xc) const; +#endif //FS_MEASURE }; #endif // __TRU64_SYSTEM_HH__ diff --git a/sim/system.cc b/sim/system.cc index af4a4c151..58e290d1a 100644 --- a/sim/system.cc +++ b/sim/system.cc @@ -40,14 +40,23 @@ int System::numSystemsRunning = 0; System::System(const std::string _name, const uint64_t _init_param, MemoryController *_memCtrl, - PhysicalMemory *_physmem) + PhysicalMemory *_physmem, + const bool _bin) : SimObject(_name), init_param(_init_param), memCtrl(_memCtrl), - physmem(_physmem) + physmem(_physmem), + bin(_bin) { // add self to global system list systemList.push_back(this); +#ifdef FS_MEASURE + if (bin == true) { + nonPath = new Statistics::MainBin("non TCPIP path stats"); + nonPath->activate(); + } else + nonPath = NULL; +#endif } @@ -95,5 +104,30 @@ printSystems() System::printSystems(); } +#ifdef FS_MEASURE +Statistics::GenBin * +System::getBin(const std::string &name) +{ + std::map<const std::string, Statistics::GenBin *>::const_iterator i; + i = fnBins.find(name); + if (i == fnBins.end()) + panic("trying to getBin that is not on system map!"); + return (*i).second; +} + +SWContext * +System::findContext(Addr pcb) +{ + std::map<Addr, SWContext *>::const_iterator iter; + iter = swCtxMap.find(pcb); + if (iter != swCtxMap.end()) { + SWContext *ctx = (*iter).second; + assert(ctx != NULL && "should never have a null ctx in ctxMap"); + return ctx; + } else + return NULL; +} +#endif //FS_MEASURE + DEFINE_SIM_OBJECT_CLASS_NAME("System", System) diff --git a/sim/system.hh b/sim/system.hh index 081aa3eb7..741dea0db 100644 --- a/sim/system.hh +++ b/sim/system.hh @@ -36,6 +36,11 @@ #include "cpu/pc_event.hh" #include "base/loader/symtab.hh" +#ifdef FS_MEASURE +#include "base/statistics.hh" +#include "sim/sw_context.hh" +#endif + class MemoryController; class PhysicalMemory; class RemoteGDB; @@ -45,10 +50,17 @@ class ExecContext; class System : public SimObject { +#ifdef FS_MEASURE + protected: + std::map<const std::string, Statistics::GenBin *> fnBins; + std::map<const Addr, SWContext *> swCtxMap; +#endif //FS_MEASURE + public: const uint64_t init_param; MemoryController *memCtrl; PhysicalMemory *physmem; + bool bin; PCEventQueue pcEventQueue; @@ -57,9 +69,14 @@ class System : public SimObject virtual int registerExecContext(ExecContext *xc); virtual void replaceExecContext(int xcIndex, ExecContext *xc); +#ifdef FS_MEASURE + Statistics::Scalar<Counter, Statistics::MainBin> fnCalls; + Statistics::MainBin *nonPath; +#endif //FS_MEASURE + public: System(const std::string _name, const uint64_t _init_param, - MemoryController *, PhysicalMemory *); + MemoryController *, PhysicalMemory *, const bool); ~System(); virtual Addr getKernelStart() const = 0; @@ -67,6 +84,21 @@ class System : public SimObject virtual Addr getKernelEntry() const = 0; virtual bool breakpoint() = 0; +#ifdef FS_MEASURE + Statistics::GenBin * getBin(const std::string &name); + virtual bool findCaller(std::string, std::string) const = 0; + + SWContext *findContext(Addr pcb); + bool addContext(Addr pcb, SWContext *ctx) { + return (swCtxMap.insert(make_pair(pcb, ctx))).second; + } + void remContext(Addr pcb) { + swCtxMap.erase(pcb); + return; + } + + virtual void dumpState(ExecContext *xc) const = 0; +#endif //FS_MEASURE public: //////////////////////////////////////////// |