summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--arch/alpha/fake_syscall.cc296
-rw-r--r--arch/alpha/isa_desc20
-rw-r--r--base/circlebuf.cc212
-rw-r--r--base/circlebuf.hh43
-rw-r--r--base/misc.cc12
-rw-r--r--base/statistics.cc69
-rw-r--r--base/statistics.hh121
-rw-r--r--cpu/exec_context.cc3
-rw-r--r--cpu/exec_context.hh8
-rw-r--r--cpu/exetrace.cc4
-rw-r--r--cpu/simple_cpu/simple_cpu.cc48
-rw-r--r--cpu/simple_cpu/simple_cpu.hh15
-rw-r--r--dev/console.cc53
-rw-r--r--dev/console.hh3
-rw-r--r--dev/etherlink.cc2
-rw-r--r--kern/tru64/tru64_events.cc48
-rw-r--r--kern/tru64/tru64_events.hh17
-rw-r--r--kern/tru64/tru64_system.cc416
-rw-r--r--kern/tru64/tru64_system.hh89
-rw-r--r--sim/main.cc20
-rw-r--r--sim/sim_object.cc48
-rw-r--r--sim/sim_object.hh4
-rw-r--r--sim/sim_time.cc14
-rw-r--r--sim/sim_time.hh4
-rw-r--r--sim/system.cc38
-rw-r--r--sim/system.hh34
26 files changed, 1334 insertions, 307 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/circlebuf.cc b/base/circlebuf.cc
index 77da26da6..7bd488ef8 100644
--- a/base/circlebuf.cc
+++ b/base/circlebuf.cc
@@ -40,148 +40,174 @@
using namespace std;
CircleBuf::CircleBuf(int l)
- : rollover(false), buflen(l), size(0), start(0), stop(0)
-{ buf = new char[buflen]; }
+ : _rollover(false), _buflen(l), _size(0), _start(0), _stop(0)
+{
+ _buf = new char[_buflen];
+}
CircleBuf::~CircleBuf()
-{ if (buf) delete [] buf; }
+{
+ if (_buf)
+ delete [] _buf;
+}
void
CircleBuf::dump()
{
- cprintf("start = %10d, stop = %10d, buflen = %10d\n", start, stop, buflen);
- fflush(stdout);
- ::write(STDOUT_FILENO, buf, buflen);
- ::write(STDOUT_FILENO, "<\n", 2);
+ cprintf("start = %10d, stop = %10d, buflen = %10d\n",
+ _start, _stop, _buflen);
+ fflush(stdout);
+ ::write(STDOUT_FILENO, _buf, _buflen);
+ ::write(STDOUT_FILENO, "<\n", 2);
}
void
CircleBuf::flush()
{
- start = 0;
- stop = 0;
- rollover = false;
+ _start = 0;
+ _stop = 0;
+ _rollover = false;
}
void
CircleBuf::read(char *b, int len)
{
- size -= len;
- if (size < 0)
- size = 0;
-
- if (stop > start) {
- len = min(len, stop - start);
- memcpy(b, buf + start, len);
- start += len;
- }
- else {
- int endlen = buflen - start;
- if (endlen > len) {
- memcpy(b, buf + start, len);
- start += len;
+ _size -= len;
+ if (_size < 0)
+ _size = 0;
+
+ if (_stop > _start) {
+ len = min(len, _stop - _start);
+ memcpy(b, _buf + _start, len);
+ _start += len;
}
else {
- memcpy(b, buf + start, endlen);
- start = min(len - endlen, stop);
- memcpy(b + endlen, buf, start);
+ int endlen = _buflen - _start;
+ if (endlen > len) {
+ memcpy(b, _buf + _start, len);
+ _start += len;
+ }
+ else {
+ memcpy(b, _buf + _start, endlen);
+ _start = min(len - endlen, _stop);
+ memcpy(b + endlen, _buf, _start);
+ }
}
- }
}
void
CircleBuf::read(int fd, int len)
{
- size -= len;
- if (size < 0)
- size = 0;
-
- if (stop > start) {
- len = min(len, stop - start);
- ::write(fd, buf + start, len);
- start += len;
- }
- else {
- int endlen = buflen - start;
- if (endlen > len) {
- ::write(fd, buf + start, len);
- start += len;
+ _size -= len;
+ if (_size < 0)
+ _size = 0;
+
+ if (_stop > _start) {
+ len = min(len, _stop - _start);
+ ::write(fd, _buf + _start, len);
+ _start += len;
}
else {
- ::write(fd, buf + start, endlen);
- start = min(len - endlen, stop);
- ::write(fd, buf, start);
+ int endlen = _buflen - _start;
+ if (endlen > len) {
+ ::write(fd, _buf + _start, len);
+ _start += len;
+ }
+ else {
+ ::write(fd, _buf + _start, endlen);
+ _start = min(len - endlen, _stop);
+ ::write(fd, _buf, _start);
+ }
}
- }
}
void
CircleBuf::read(int fd)
{
- size = 0;
+ _size = 0;
+
+ if (_stop > _start) {
+ ::write(fd, _buf + _start, _stop - _start);
+ }
+ else {
+ ::write(fd, _buf + _start, _buflen - _start);
+ ::write(fd, _buf, _stop);
+ }
+
+ _start = _stop;
+}
+
+void
+CircleBuf::read(ostream &out)
+{
+ _size = 0;
- if (stop > start) {
- ::write(fd, buf + start, stop - start);
- }
- else {
- ::write(fd, buf + start, buflen - start);
- ::write(fd, buf, stop);
- }
+ if (_stop > _start) {
+ out.write(_buf + _start, _stop - _start);
+ }
+ else {
+ out.write(_buf + _start, _buflen - _start);
+ out.write(_buf, _stop);
+ }
- start = stop;
+ _start = _stop;
}
void
CircleBuf::readall(int fd)
{
- if (rollover)
- ::write(fd, buf + stop, buflen - stop);
+ if (_rollover)
+ ::write(fd, _buf + _stop, _buflen - _stop);
- ::write(fd, buf, stop);
- start = stop;
+ ::write(fd, _buf, _stop);
+ _start = _stop;
}
void
CircleBuf::write(char b)
-{ write(&b, 1); }
+{
+ write(&b, 1);
+}
void
CircleBuf::write(const char *b)
-{ write(b, strlen(b)); }
+{
+ write(b, strlen(b));
+}
void
CircleBuf::write(const char *b, int len)
{
- if (len <= 0)
- return;
-
- size += len;
- if (size > buflen)
- size = buflen;
-
- int old_start = start;
- int old_stop = stop;
-
- if (len >= buflen) {
- start = 0;
- stop = buflen;
- rollover = true;
- memcpy(buf, b + (len - buflen), buflen);
- return;
- }
-
- if (stop + len <= buflen) {
- memcpy(buf + stop, b, len);
- stop += len;
- } else {
- int end_len = buflen - old_stop;
- stop = len - end_len;
- memcpy(buf + old_stop, b, end_len);
- memcpy(buf, b + end_len, stop);
- rollover = true;
- }
-
- if (old_start > old_stop && old_start < stop ||
- old_start < old_stop && stop < old_stop)
- start = stop + 1;
+ if (len <= 0)
+ return;
+
+ _size += len;
+ if (_size > _buflen)
+ _size = _buflen;
+
+ int old_start = _start;
+ int old_stop = _stop;
+
+ if (len >= _buflen) {
+ _start = 0;
+ _stop = _buflen;
+ _rollover = true;
+ memcpy(_buf, b + (len - _buflen), _buflen);
+ return;
+ }
+
+ if (_stop + len <= _buflen) {
+ memcpy(_buf + _stop, b, len);
+ _stop += len;
+ } else {
+ int end_len = _buflen - old_stop;
+ _stop = len - end_len;
+ memcpy(_buf + old_stop, b, end_len);
+ memcpy(_buf, b + end_len, _stop);
+ _rollover = true;
+ }
+
+ if (old_start > old_stop && old_start < _stop ||
+ old_start < old_stop && _stop < old_stop)
+ _start = _stop + 1;
}
diff --git a/base/circlebuf.hh b/base/circlebuf.hh
index e0abed31c..168158bb7 100644
--- a/base/circlebuf.hh
+++ b/base/circlebuf.hh
@@ -29,31 +29,34 @@
#ifndef __CIRCLEBUF_HH__
#define __CIRCLEBUF_HH__
+#include <iosfwd>
class CircleBuf
{
-protected:
- char *buf;
- bool rollover;
- int buflen;
- int size;
- int start;
- int stop;
+ protected:
+ char *_buf;
+ bool _rollover;
+ int _buflen;
+ int _size;
+ int _start;
+ int _stop;
-public:
- explicit CircleBuf(int l);
- ~CircleBuf();
+ public:
+ explicit CircleBuf(int l);
+ ~CircleBuf();
- bool empty() { return size == 0; }
- void dump();
- void flush();
- void read(char *b, int len);
- void read(int fd, int len);
- void read(int fd);
- void readall(int fd);
- void write(char b);
- void write(const char *b);
- void write(const char *b, int len);
+ bool empty() const { return _size == 0; }
+ int size() const { return _size; }
+ void dump();
+ void flush();
+ void read(char *b, int len);
+ void read(int fd, int len);
+ void read(int fd);
+ void read(std::ostream &out);
+ void readall(int fd);
+ void write(char b);
+ void write(const char *b);
+ void write(const char *b, int len);
};
#endif // __CIRCLEBUF_HH__
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 c1a5b2626..3af764609 100644
--- a/base/statistics.cc
+++ b/base/statistics.cc
@@ -160,7 +160,7 @@ Database::~Database()
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 +169,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();
@@ -177,26 +178,38 @@ Database::dump(ostream &stream)
ccprintf(stream, "PRINTING BINNED STATS\n");
while (j != bins_end) {
(*j)->activate();
- map<const GenBin *, std::string>::const_iterator iter;
+ map<const GenBin *, std::string>::const_iterator iter;
iter = bin_names.find(*j);
if (iter == bin_names.end())
panic("a binned stat not found in names map!");
ccprintf(stream,"---%s Bin------------\n", (*iter).second);
- list_t::iterator i = binnedStats.begin();
- list_t::iterator end = binnedStats.end();
- while (i != end) {
- Stat *stat = *i;
- if (stat->dodisplay())
- stat->display(stream);
- ++i;
- }
- ++j;
- ccprintf(stream, "---------------------------------\n");
+#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())
+ stat->display(stream);
+ ++i;
+ }
+ ++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 +218,7 @@ Database::dump(ostream &stream)
stat->display(stream);
++k;
}
+#endif
}
StatData *
@@ -252,11 +266,26 @@ Database::reset()
{
list_t::iterator i = allStats.begin();
list_t::iterator end = allStats.end();
-
while (i != end) {
- (*i)->reset();
+ Stat *stat = *i;
+ stat->reset();
++i;
}
+
+ list<GenBin *>::iterator bi = bins.begin();
+ list<GenBin *>::iterator be = bins.end();
+ while (bi != be) {
+ GenBin *bin = *bi;
+ bin->activate();
+
+ i = allStats.begin();
+ while (i != end) {
+ Stat *stat = *i;
+ stat->reset();
+ ++i;
+ }
+ ++bi;
+ }
}
void
@@ -714,7 +743,7 @@ VectorDisplay(std::ostream &stream,
_pdf = vec[i] / _total;
_cdf += _pdf;
} else {
- _pdf = _cdf = 0.0;
+ _pdf = _cdf = NAN;
}
if (!(myflags & cdf)) {
PrintOne(stream, vec[i], subname, subdesc, myprecision,
@@ -746,10 +775,8 @@ VectorDisplay(std::ostream &stream,
_pdf = vec[i] / _total;
_cdf += _pdf;
} else {
- _pdf = _cdf = 0.0;
+ _pdf = _cdf = NAN;
}
- _pdf = vec[i] / _total;
- _cdf += _pdf;
PrintOne(stream, vec[i], name, mydesc, myprecision,
myflags, _pdf, _cdf);
}
@@ -864,14 +891,18 @@ DistDisplay(ostream &stream, const string &name, const string &desc,
}
#endif
+/**
+ * @todo get rid of the ugly hack **Ignore for total
+ */
void
FancyDisplay(ostream &stream, const string &name, const string &desc,
int precision, FormatFlags flags, result_t mean,
- result_t variance)
+ result_t variance, result_t total)
{
result_t stdev = isnan(variance) ? NAN : sqrt(variance);
PrintOne(stream, mean, name + NAMESEP + "mean", desc, precision, flags);
PrintOne(stream, stdev, name + NAMESEP + "stdev", desc, precision, flags);
+ PrintOne(stream, total, "**Ignore: " + name + NAMESEP + "TOT", desc, precision, flags);
}
BinBase::BinBase()
diff --git a/base/statistics.hh b/base/statistics.hh
index 2fe6988b0..28c380602 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
//
@@ -464,12 +467,17 @@ template <typename T>
struct AvgStor
{
public:
- /** The paramaters for this storage type, none for this average. */
- struct Params { };
+ /** The paramaters for this storage type */
+ struct Params
+ {
+ /**
+ * The current count. We stash this here because the current
+ * value is not a binned value.
+ */
+ T current;
+ };
private:
- /** The current count. */
- T current;
/** The total count for all cycles. */
mutable result_t total;
/** The cycle that current last changed. */
@@ -479,7 +487,7 @@ struct AvgStor
/**
* Build and initializes this stat storage.
*/
- AvgStor(const Params &) : current(T()), total(0), last(0) { }
+ AvgStor(Params &p) : total(0), last(0) { p.current = T(); }
/**
* Set the current count to the one provided, update the total and last
@@ -487,45 +495,49 @@ struct AvgStor
* @param val The new count.
* @param p The parameters for this storage.
*/
- void set(T val, const Params &p) {
- total += current * (curTick - last);
+ void set(T val, Params &p) {
+ total += p.current * (curTick - last);
last = curTick;
- current = val;
+ p.current = val;
}
+
/**
* Increment the current count by the provided value, calls set.
* @param val The amount to increment.
* @param p The parameters for this storage.
*/
- void inc(T val, const Params &p) { set(current + val, p); }
+ void inc(T val, Params &p) { set(p.current + val, p); }
+
/**
* Deccrement the current count by the provided value, calls set.
* @param val The amount to decrement.
* @param p The parameters for this storage.
*/
- void dec(T val, const Params &p) { set(current - val, p); }
+ void dec(T val, Params &p) { set(p.current - val, p); }
+
/**
* Return the current average.
* @param p The parameters for this storage.
* @return The current average.
*/
result_t val(const Params &p) const {
- total += current * (curTick - last);
+ total += p.current * (curTick - last);
last = curTick;
- return (result_t)(total + current) / (result_t)(curTick + 1);
+ return (result_t)(total + p.current) / (result_t)(curTick + 1);
}
+
/**
* Return the current count.
* @param p The parameters for this storage.
* @return The current count.
*/
- T value(const Params &p) const { return current; }
+ T value(const Params &p) const { return p.current; }
+
/**
* Reset stat value to default
*/
void reset()
{
- current = T();
total = 0;
last = curTick;
}
@@ -563,8 +575,11 @@ class ScalarBase : public ScalarStat
* Retrieve a const pointer to the storage from the bin.
* @return A const pointer to the storage object for this stat.
*/
- const storage_t *data() const {
- return (const_cast<bin_t *>(&bin))->data(params);
+ const storage_t *data() const
+ {
+ bin_t *_bin = const_cast<bin_t *>(&bin);
+ params_t *_params = const_cast<params_t *>(&params);
+ return _bin->data(*_params);
}
protected:
@@ -703,8 +718,11 @@ class VectorBase : public VectorStat
* @param index The vector index to access.
* @return A const pointer to the storage object at the given index.
*/
- const storage_t *data(int index) const {
- return (const_cast<bin_t *>(&bin))->data(index, params);
+ const storage_t *data(int index) const
+ {
+ bin_t *_bin = const_cast<bin_t *>(&bin);
+ params_t *_params = const_cast<params_t *>(&params);
+ return _bin->data(index, *_params);
}
protected:
@@ -823,7 +841,12 @@ class ScalarProxy : public ScalarStat
* Retrieve a const pointer to the storage from the bin.
* @return A const pointer to the storage for this stat.
*/
- const storage_t *data() const { return bin->data(index, *params); }
+ const storage_t *data() const
+ {
+ bin_t *_bin = const_cast<bin_t *>(bin);
+ params_t *_params = const_cast<params_t *>(params);
+ return _bin->data(index, *_params);
+ }
public:
/**
@@ -950,8 +973,11 @@ class Vector2dBase : public Stat
protected:
storage_t *data(int index) { return bin.data(index, params); }
- const storage_t *data(int index) const {
- return (const_cast<bin_t *>(&bin))->data(index, params);
+ const storage_t *data(int index) const
+ {
+ bin_t *_bin = const_cast<bin_t *>(&bin);
+ params_t *_params = const_cast<params_t *>(&params);
+ return _bin->data(index, *_params);
}
protected:
@@ -1079,7 +1105,9 @@ class VectorProxy : public VectorStat
}
const storage_t *data(int index) const {
- return (const_cast<bin_t *>(bin))->data(offset + index, *params);
+ bin_t *_bin = const_cast<bin_t *>(bin);
+ params_t *_params = const_cast<params_t *>(params);
+ return _bin->data(offset + index, *_params);
}
public:
@@ -1306,7 +1334,7 @@ struct DistStor
void FancyDisplay(std::ostream &stream, const std::string &name,
const std::string &desc, int precision, FormatFlags flags,
- result_t mean, result_t variance);
+ result_t mean, result_t variance, result_t total);
/**
* Templatized storage and interface for a distribution that calculates mean
@@ -1366,16 +1394,16 @@ struct FancyStor
result_t mean = NAN;
result_t variance = NAN;
+ result_t ftot = total;
if (total != 0) {
result_t fsum = sum;
result_t fsq = squares;
- result_t ftot = total;
mean = fsum / ftot;
variance = (ftot * fsq - (fsum * fsum)) / (ftot * (ftot - 1.0));
}
- FancyDisplay(stream, name, desc, precision, flags, mean, variance);
+ FancyDisplay(stream, name, desc, precision, flags, mean, variance, ftot);
}
/**
@@ -1504,8 +1532,11 @@ class DistBase : public Stat
* Retrieve a const pointer to the storage from the bin.
* @return A const pointer to the storage object for this stat.
*/
- const storage_t *data() const {
- return (const_cast<bin_t *>(&bin))->data(params);
+ const storage_t *data() const
+ {
+ bin_t *_bin = const_cast<bin_t *>(&bin);
+ params_t *_params = const_cast<params_t *>(&params);
+ return _bin->data(*_params);
}
protected:
@@ -1583,8 +1614,11 @@ class VectorDistBase : public Stat
protected:
storage_t *data(int index) { return bin.data(index, params); }
- const storage_t *data(int index) const {
- return (const_cast<bin_t *>(&bin))->data(index, params);
+ const storage_t *data(int index) const
+ {
+ bin_t *_bin = const_cast<bin_t *>(&bin);
+ params_t *_params = const_cast<params_t *>(&params);
+ return _bin->data(index, *_params);
}
protected:
@@ -2167,6 +2201,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 +2233,6 @@ struct StatBin : public GenBin
// That one is for the last trailing flags byte.
offset() += (size + 1 + mask) & ~mask;
-
return off;
}
@@ -2212,7 +2246,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
@@ -2241,11 +2280,11 @@ struct StatBin : public GenBin
enum { binned = true };
Bin() { allocate(sizeof(Storage)); }
bool initialized() const { return true; }
- void init(const Params &params) { }
+ void init(Params &params) { }
int size() const { return 1; }
- Storage *data(const Params &params) {
+ Storage *data(Params &params) {
assert(initialized());
char *ptr = access();
char *flags = ptr + sizeof(Storage);
@@ -2281,7 +2320,7 @@ struct StatBin : public GenBin
VectorBin() : _size(0) {}
bool initialized() const { return _size > 0; }
- void init(int s, const Params &params) {
+ void init(int s, Params &params) {
assert(!initialized());
assert(s > 0);
_size = s;
@@ -2290,7 +2329,7 @@ struct StatBin : public GenBin
int size() const { return _size; }
- Storage *data(int index, const Params &params) {
+ Storage *data(int index, Params &params) {
assert(initialized());
assert(index >= 0 && index < size());
char *ptr = access();
@@ -2340,11 +2379,11 @@ struct NoBin
}
bool initialized() const { return true; }
- void init(const Params &params) {
+ void init(Params &params) {
new (ptr) Storage(params);
}
int size() const{ return 1; }
- Storage *data(const Params &params) {
+ Storage *data(Params &params) {
assert(initialized());
return reinterpret_cast<Storage *>(ptr);
}
@@ -2381,7 +2420,7 @@ struct NoBin
}
bool initialized() const { return ptr != NULL; }
- void init(int s, const Params &params) {
+ void init(int s, Params &params) {
assert(s > 0 && "size must be positive!");
assert(!initialized());
_size = s;
@@ -2392,7 +2431,7 @@ struct NoBin
int size() const { return _size; }
- Storage *data(int index, const Params &params) {
+ Storage *data(int index, Params &params) {
assert(initialized());
assert(index >= 0 && index < size());
return reinterpret_cast<Storage *>(ptr + index * sizeof(Storage));
@@ -2426,7 +2465,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(&regs, 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..a63f86098 100644
--- a/cpu/simple_cpu/simple_cpu.cc
+++ b/cpu/simple_cpu/simple_cpu.cc
@@ -159,8 +159,9 @@ SimpleCPU::SimpleCPU(const string &_name, Process *_process,
memReq->data = new uint8_t[64];
numInst = 0;
+ startNumInst = 0;
numLoad = 0;
- last_idle = 0;
+ startNumLoad = 0;
lastIcacheStall = 0;
lastDcacheStall = 0;
@@ -171,7 +172,6 @@ SimpleCPU::~SimpleCPU()
{
}
-
void
SimpleCPU::switchOut()
{
@@ -217,6 +217,8 @@ SimpleCPU::execCtxStatusChg(int thread_num) {
void
SimpleCPU::regStats()
{
+ using namespace Statistics;
+
BaseCPU::regStats();
numInsts
@@ -229,11 +231,6 @@ SimpleCPU::regStats()
.desc("Number of memory references")
;
- idleCycles
- .name(name() + ".idle_cycles")
- .desc("Number of idle cycles")
- ;
-
idleFraction
.name(name() + ".idle_fraction")
.desc("Percentage of idle cycles")
@@ -251,13 +248,17 @@ SimpleCPU::regStats()
.prereq(dcacheStallCycles)
;
- idleFraction = idleCycles / simTicks;
-
- numInsts = Statistics::scalar(numInst);
+ numInsts = Statistics::scalar(numInst) - Statistics::scalar(startNumInst);
simInsts += numInsts;
}
void
+SimpleCPU::resetStats()
+{
+ startNumInst = numInst;
+}
+
+void
SimpleCPU::serialize(ostream &os)
{
SERIALIZE_ENUM(_status);
@@ -627,7 +628,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..b0189349f 100644
--- a/cpu/simple_cpu/simple_cpu.hh
+++ b/cpu/simple_cpu/simple_cpu.hh
@@ -207,7 +207,7 @@ class SimpleCPU : public BaseCPU
case Idle:
assert(old_status == Running);
- last_idle = curTick;
+ idleFraction++;
if (tickEvent.scheduled())
tickEvent.squash();
break;
@@ -216,8 +216,8 @@ class SimpleCPU : public BaseCPU
assert(old_status == Idle ||
old_status == DcacheMissStall ||
old_status == IcacheMissComplete);
- if (old_status == Idle)
- idleCycles += curTick - last_idle;
+ if (old_status == Idle && curTick != 0)
+ idleFraction--;
if (tickEvent.squashed())
tickEvent.reschedule(curTick + 1);
@@ -231,10 +231,12 @@ class SimpleCPU : public BaseCPU
}
// statistics
- void regStats();
+ virtual void regStats();
+ virtual void resetStats();
// number of simulated instructions
Counter numInst;
+ Counter startNumInst;
Statistics::Formula numInsts;
// number of simulated memory references
@@ -242,11 +244,10 @@ class SimpleCPU : public BaseCPU
// number of simulated loads
Counter numLoad;
+ Counter startNumLoad;
// number of idle cycles
- Statistics::Scalar<> idleCycles;
- Statistics::Formula idleFraction;
- Counter last_idle;
+ Statistics::Average<> idleFraction;
// number of cycles stalled for I-cache misses
Statistics::Scalar<> icacheStallCycles;
diff --git a/dev/console.cc b/dev/console.cc
index 2378f8c75..ab2a284aa 100644
--- a/dev/console.cc
+++ b/dev/console.cc
@@ -73,6 +73,9 @@ SimConsole::Event::process(int revent)
SimConsole::SimConsole(const string &name, const string &file, int num)
: SimObject(name), event(NULL), number(num), in_fd(-1), out_fd(-1),
listener(NULL), txbuf(16384), rxbuf(16384), outfile(NULL),
+#if TRACING_ON == 1
+ linebuf(16384),
+#endif
_status(0), _enable(0), intr(NULL)
{
if (!file.empty())
@@ -111,8 +114,8 @@ SimConsole::attach(int in, int out, ConsoleListener *l)
pollQueue.schedule(event);
stringstream stream;
- ccprintf(stream, "==== Simplescalar slave console: Console %d ====",
- number);
+ ccprintf(stream, "==== m5 slave console: Console %d ====", number);
+
// we need an actual carriage return followed by a newline for the
// terminal
stream << "\r\n";
@@ -231,7 +234,7 @@ SimConsole::in()
char c;
rxbuf.read(&c, 1);
- DPRINTF(Console, "in: \'%c\' %#02x status: %#x\n",
+ DPRINTF(ConsoleVerbose, "in: \'%c\' %#02x status: %#x\n",
isprint(c) ? c : ' ', c, _status);
return c;
@@ -240,6 +243,28 @@ SimConsole::in()
void
SimConsole::out(char c, bool raise_int)
{
+#if TRACING_ON == 1
+ if (DTRACE(Console)) {
+ static char last = '\0';
+
+ if (c != '\n' && c != '\r' ||
+ last != '\n' && last != '\r') {
+ if (c == '\n' || c == '\r') {
+ int size = linebuf.size();
+ char *buffer = new char[size + 1];
+ linebuf.read(buffer, size);
+ buffer[size] = '\0';
+ DPRINTF(Console, "%s\n", buffer);
+ delete [] buffer;
+ } else {
+ linebuf.write(c);
+ }
+ }
+
+ last = c;
+ }
+#endif
+
txbuf.write(c);
if (out_fd >= 0)
@@ -251,13 +276,13 @@ SimConsole::out(char c, bool raise_int)
if (raise_int)
raiseInt(TransmitInterrupt);
- DPRINTF(Console, "out: \'%c\' %#02x",
+ DPRINTF(ConsoleVerbose, "out: \'%c\' %#02x",
isprint(c) ? c : ' ', (int)c);
if (raise_int)
- DPRINTF(Console, "status: %#x\n", _status);
+ DPRINTF(ConsoleVerbose, "status: %#x\n", _status);
else
- DPRINTF(Console, "\n");
+ DPRINTF(ConsoleVerbose, "\n");
}
inline bool
@@ -329,6 +354,7 @@ BEGIN_DECLARE_SIM_OBJECT_PARAMS(SimConsole)
SimObjectParam<ConsoleListener *> listener;
SimObjectParam<IntrControl *> intr_control;
Param<string> output;
+ Param<bool> append_name;
Param<int> number;
END_DECLARE_SIM_OBJECT_PARAMS(SimConsole)
@@ -338,13 +364,17 @@ BEGIN_INIT_SIM_OBJECT_PARAMS(SimConsole)
INIT_PARAM(listener, "console listener"),
INIT_PARAM(intr_control, "interrupt controller"),
INIT_PARAM_DFLT(output, "file to dump output to", ""),
+ INIT_PARAM_DFLT(append_name, "append name() to filename", true),
INIT_PARAM_DFLT(number, "console number", 0)
END_INIT_SIM_OBJECT_PARAMS(SimConsole)
CREATE_SIM_OBJECT(SimConsole)
{
- SimConsole *console = new SimConsole(getInstanceName(), output, number);
+ string filename = output;
+ if (!filename.empty() && append_name)
+ filename += "." + getInstanceName();
+ SimConsole *console = new SimConsole(getInstanceName(), filename, number);
((ConsoleListener *)listener)->add(console);
((SimConsole *)console)->initInt(intr_control);
((SimConsole *)console)->setInt(SimConsole::TransmitInterrupt |
@@ -383,12 +413,14 @@ void
ConsoleListener::listen(int port)
{
while (!listener.listen(port, true)) {
- DPRINTF(Console, ": can't bind address console port %d inuse PID %d\n",
+ DPRINTF(Console,
+ ": can't bind address console port %d inuse PID %d\n",
port, getpid());
port++;
}
- cerr << "Listening for console connection on port " << port << endl;
+ ccprintf(cerr, "Listening for console connection on port %d\n", port);
+
event = new Event(this, listener.getfd(), POLLIN);
pollQueue.schedule(event);
}
@@ -401,8 +433,7 @@ void
ConsoleListener::accept()
{
if (!listener.islistening())
- panic("%s: cannot accept a connection if we're not listening!",
- name());
+ panic("%s: cannot accept a connection if not listening!", name());
int sfd = listener.accept(true);
if (sfd != -1) {
diff --git a/dev/console.hh b/dev/console.hh
index fd02e7a9a..f443afe4f 100644
--- a/dev/console.hh
+++ b/dev/console.hh
@@ -74,6 +74,9 @@ class SimConsole : public SimObject
CircleBuf txbuf;
CircleBuf rxbuf;
std::ostream *outfile;
+#if TRACING_ON == 1
+ CircleBuf linebuf;
+#endif
public:
///////////////////////
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..f542256e4 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,46 @@ 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)) {
+ 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..f6f147d07 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,100 @@ 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));
+
+ readBin = new Statistics::MainBin(name() + " read");
+ fnBins.insert(make_pair("read", readBin));
+
+ sooReadBin = new Statistics::MainBin(name() + " soo_read");
+ fnBins.insert(make_pair("soo_read", sooReadBin));
+
+ 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));
+
+ writeBin = new Statistics::MainBin(name() + " write");
+ fnBins.insert(make_pair("write", writeBin));
+
+ sooWriteBin = new Statistics::MainBin(name() + " soo_write");
+ fnBins.insert(make_pair("soo_write", sooWriteBin));
+
+ 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 +200,42 @@ 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);
+ readEvent = new FnEvent(&pcEventQueue, "read", this);
+ sooReadEvent = new FnEvent(&pcEventQueue, "soo_read", 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);
+ writeEvent = new FnEvent(&pcEventQueue, "write", this);
+ sooWriteEvent = new FnEvent(&pcEventQueue, "soo_write", 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 +286,198 @@ 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("read", addr))
+ readEvent->schedule(addr);
+ else
+ panic("could not find kernel symbol \'read\'");
+
+ if (kernelSymtab->findAddress("soo_read", addr))
+ sooReadEvent->schedule(addr);
+ else
+ panic("could not find kernel symbol \'soo_read\'");
+
+ 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("write", addr))
+ writeEvent->schedule(addr);
+ else
+ panic("could not find kernel symbol \'write\'");
+
+ if (kernelSymtab->findAddress("soo_write", addr))
+ sooWriteEvent->schedule(addr);
+ else
+ panic("could not find kernel symbol \'soo_write\'");
+
+ 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("soo_read", "read");
+ populateMap("recvit", "orecv");
+ populateMap("soreceive", "recvit");
+ populateMap("soreceive", "soo_read");
+
+ 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 +498,41 @@ 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 readEvent;
+ delete sooReadEvent;
+ delete orecvEvent;
+ delete recvitEvent;
+ delete soreceiveEvent;
+ delete osendEvent;
+ delete writeEvent;
+ delete sooWriteEvent;
+ 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 +571,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 +631,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 +639,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 +648,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..42107494f 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,40 @@ 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 *readBin;
+ Statistics::MainBin *sooReadBin;
+ Statistics::MainBin *orecvBin;
+ Statistics::MainBin *recvitBin;
+ Statistics::MainBin *soreceiveBin;
+ Statistics::MainBin *osendBin;
+ Statistics::MainBin *writeBin;
+ Statistics::MainBin *sooWriteBin;
+ 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 +105,51 @@ 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 *readEvent;
+ FnEvent *sooReadEvent;
+ FnEvent *orecvEvent;
+ FnEvent *recvitEvent;
+ FnEvent *soreceiveEvent;
+ FnEvent *osendEvent;
+ FnEvent *writeEvent;
+ FnEvent *sooWriteEvent;
+ 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 +163,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 +177,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/main.cc b/sim/main.cc
index addedbc85..4fb075a2a 100644
--- a/sim/main.cc
+++ b/sim/main.cc
@@ -59,6 +59,7 @@ using namespace std;
// See async.h.
volatile bool async_event = false;
volatile bool async_dump = false;
+volatile bool async_dumpreset = false;
volatile bool async_exit = false;
volatile bool async_io = false;
volatile bool async_alarm = false;
@@ -71,6 +72,13 @@ dumpStatsHandler(int sigtype)
async_dump = true;
}
+void
+dumprstStatsHandler(int sigtype)
+{
+ async_event = true;
+ async_dumpreset = true;
+}
+
/// Exit signal handler.
void
exitNowHandler(int sigtype)
@@ -219,8 +227,9 @@ main(int argc, char **argv)
signal(SIGFPE, SIG_IGN); // may occur on misspeculated paths
signal(SIGPIPE, SIG_IGN);
signal(SIGTRAP, SIG_IGN);
- signal(SIGUSR1, dumpStatsHandler); // dump intermediate stats
- signal(SIGINT, exitNowHandler); // dump final stats and exit
+ signal(SIGUSR1, dumpStatsHandler); // dump intermediate stats
+ signal(SIGUSR2, dumprstStatsHandler); // dump and reset stats
+ signal(SIGINT, exitNowHandler); // dump final stats and exit
sayHello(cerr);
@@ -405,6 +414,13 @@ main(int argc, char **argv)
SetupEvent(Dump, curTick);
}
+ if (async_dumpreset) {
+ async_dumpreset = false;
+
+ using namespace Statistics;
+ SetupEvent(Dump | Reset, curTick);
+ }
+
if (async_exit) {
async_exit = false;
new SimExitEvent("User requested STOP");
diff --git a/sim/sim_object.cc b/sim/sim_object.cc
index af6a258ff..dbc2cf7be 100644
--- a/sim/sim_object.cc
+++ b/sim/sim_object.cc
@@ -28,12 +28,13 @@
#include <assert.h>
-#include "sim/sim_object.hh"
+#include "base/callback.hh"
#include "base/inifile.hh"
-#include "sim/configfile.hh"
-#include "sim/host.hh"
#include "base/misc.hh"
#include "base/trace.hh"
+#include "sim/configfile.hh"
+#include "sim/host.hh"
+#include "sim/sim_object.hh"
#include "sim/sim_stats.hh"
using namespace std;
@@ -72,6 +73,11 @@ SimObject::regFormulas()
{
}
+void
+SimObject::resetStats()
+{
+}
+
//
// no default extra output
//
@@ -85,6 +91,15 @@ SimObject::printExtraOutput(ostream &os)
// call regStats() on all SimObjects and then regFormulas() on all
// SimObjects.
//
+struct SimObjectResetCB : public Callback
+{
+ virtual void process() { SimObject::resetAllStats(); }
+};
+
+namespace {
+ static SimObjectResetCB StatResetCB;
+}
+
void
SimObject::regAllStats()
{
@@ -106,7 +121,24 @@ SimObject::regAllStats()
cprintf("registering formulas for %s\n", (*i)->name());
#endif
(*i)->regFormulas();
- }
+ }
+
+ Statistics::RegResetCallback(&StatResetCB);
+}
+
+//
+// static function: call resetStats() on all SimObjects.
+//
+void
+SimObject::resetAllStats()
+{
+ SimObjectList::iterator i = simObjectList.begin();
+ SimObjectList::iterator end = simObjectList.end();
+
+ for (; i != end; ++i) {
+ SimObject *obj = *i;
+ obj->resetStats();
+ }
}
//
@@ -115,9 +147,11 @@ SimObject::regAllStats()
void
SimObject::printAllExtraOutput(ostream &os)
{
- SimObjectList::iterator i;
+ SimObjectList::iterator i = simObjectList.begin();
+ SimObjectList::iterator end = simObjectList.end();
- for (i = simObjectList.begin(); i != simObjectList.end(); ++i) {
- (*i)->printExtraOutput(os);
+ for (; i != end; ++i) {
+ SimObject *obj = *i;
+ obj->printExtraOutput(os);
}
}
diff --git a/sim/sim_object.hh b/sim/sim_object.hh
index 1a365651b..6b26a1cb0 100644
--- a/sim/sim_object.hh
+++ b/sim/sim_object.hh
@@ -68,6 +68,7 @@ class SimObject : public Serializeable
// register statistics for this object
virtual void regStats();
virtual void regFormulas();
+ virtual void resetStats();
// print extra results for this object not covered by registered
// statistics (called at end of simulation)
@@ -76,6 +77,9 @@ class SimObject : public Serializeable
// static: call reg_stats on all SimObjects
static void regAllStats();
+ // static: call resetStats on all SimObjects
+ static void resetAllStats();
+
// static: call printExtraOutput on all SimObjects
static void printAllExtraOutput(std::ostream&);
};
diff --git a/sim/sim_time.cc b/sim/sim_time.cc
index 70483d9a2..09c5a66de 100644
--- a/sim/sim_time.cc
+++ b/sim/sim_time.cc
@@ -65,6 +65,12 @@ namespace Time
return start->tv;
}
+ void
+ Start::reset()
+ {
+ ::gettimeofday(&start->tv, NULL);
+ }
+
double
Start::operator()() const
{
@@ -115,10 +121,16 @@ namespace Time
if (!elapsed)
elapsed = new _timeval;
- timersub(&now.get(), &start.get(), &elapsed->tv);
+ timersub(&_now.get(), &_start.get(), &elapsed->tv);
return elapsed->tv;
}
+ void
+ Elapsed::reset()
+ {
+ _start.reset();
+ }
+
double
Elapsed::operator()() const
{
diff --git a/sim/sim_time.hh b/sim/sim_time.hh
index af69c3321..02ca5534f 100644
--- a/sim/sim_time.hh
+++ b/sim/sim_time.hh
@@ -45,6 +45,7 @@ namespace Time {
~Start();
const timeval &get() const;
+ void reset();
double operator()() const;
};
@@ -65,12 +66,15 @@ namespace Time {
{
private:
mutable _timeval *elapsed;
+ Start _start;
+ Now _now;
public:
Elapsed();
~Elapsed();
const timeval &get() const;
+ void reset();
double operator()() const;
};
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:
////////////////////////////////////////////
generated by cgit v1.2.3 (git 2.25.1) at 2025-03-23 17:27:55 +0000