sanchayanmaity/gem5
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

We only need to choose that we do want binning, or we don't.

Browse source 
no need for multiple bin classes.  If multiple bins are needed, we
can always do it with ini type config instead.

kern/tru64/tru64_events.hh:
sim/system.cc:
sim/system.hh:
    No more GenBin always use MainBin

--HG--
extra : convert_revision : 8c466f302324c33b59d47d0da04583b2517fc72c
This commit is contained in:
Nathan Binkert 2003-11-22 15:07:53 -05:00
parent 92348c503c
commit d1e12b57ce
5 changed files with 72 additions and 84 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

43
base/statistics.cc
View file

@ -129,8 +129,8 @@ class Database
typedef list<Stat *> list_t; typedef list<Stat *> list_t;
typedef map<const Stat *, StatData *> map_t; typedef map<const Stat *, StatData *> map_t;
list<GenBin *> bins; list<MainBin *> bins;
map<const GenBin *, std::string > bin_names; map<const MainBin *, std::string > bin_names;
list_t binnedStats; list_t binnedStats;
list_t allStats; list_t allStats;
@ -148,7 +148,7 @@ class Database
void reset(); void reset();
void regStat(Stat *stat); void regStat(Stat *stat);
StatData *print(Stat *stat); StatData *print(Stat *stat);
void regBin(GenBin *bin, std::string name); void regBin(MainBin *bin, std::string name);
}; };
Database::Database() Database::Database()
@ -171,14 +171,14 @@ Database::dump(ostream &stream)
} }
#endif //FS_MEASURE #endif //FS_MEASURE
list<GenBin *>::iterator j = bins.begin(); list<MainBin *>::iterator j = bins.begin();
list<GenBin *>::iterator bins_end=bins.end(); list<MainBin *>::iterator bins_end=bins.end();
if (!bins.empty()) { if (!bins.empty()) {
ccprintf(stream, "PRINTING BINNED STATS\n"); ccprintf(stream, "PRINTING BINNED STATS\n");
while (j != bins_end) { while (j != bins_end) {
(*j)->activate(); (*j)->activate();
map<const GenBin *, std::string>::const_iterator iter; map<const MainBin *, std::string>::const_iterator iter;
iter = bin_names.find(*j); iter = bin_names.find(*j);
if (iter == bin_names.end()) if (iter == bin_names.end())
panic("a binned stat not found in names map!"); panic("a binned stat not found in names map!");
@ -274,10 +274,10 @@ Database::reset()
MainBin *orig = MainBin::curBin(); MainBin *orig = MainBin::curBin();
list<GenBin *>::iterator bi = bins.begin(); list<MainBin *>::iterator bi = bins.begin();
list<GenBin *>::iterator be = bins.end(); list<MainBin *>::iterator be = bins.end();
while (bi != be) { while (bi != be) {
GenBin *bin = *bi; MainBin *bin = *bi;
bin->activate(); bin->activate();
i = allStats.begin(); i = allStats.begin();
@ -308,7 +308,7 @@ Database::regStat(Stat *stat)
} }
void void
Database::regBin(GenBin *bin, std::string name) Database::regBin(MainBin *bin, std::string name)
{ {
if (bin_names.find(bin) != bin_names.end()) if (bin_names.find(bin) != bin_names.end())
panic("shouldn't register bin twice"); panic("shouldn't register bin twice");
@ -910,36 +910,35 @@ FancyDisplay(ostream &stream, const string &name, const string &desc,
PrintOne(stream, total, "**Ignore: " + name + NAMESEP + "TOT", desc, precision, flags); PrintOne(stream, total, "**Ignore: " + name + NAMESEP + "TOT", desc, precision, flags);
} }
BinBase::BinBase() } // namespace Detail
: mem(NULL), memsize(-1)
MainBin::MainBin(const std::string &name)
: _name(name), mem(NULL), memsize(-1)
{ {
Detail::StatDB().regBin(this, name);
} }
BinBase::~BinBase() MainBin::~MainBin()
{ {
if (mem) if (mem)
delete [] mem; delete [] mem;
} }
char * char *
BinBase::memory() MainBin::memory(off_t off)
{ {
if (!mem) { if (!mem) {
mem = new char[memsize]; mem = new char[memsize];
memset(mem, 0, memsize); memset(mem, 0, memsize);
} }
return mem; if (memsize == -1)
} memsize = CeilPow2((size_t) offset());
void assert(offset() <= size());
GenBin::regBin(GenBin *bin, std::string name) return mem + off;
{
Detail::StatDB().regBin(bin, name);
} }
} // namespace Detail
void void
check() check()
{ {

103
base/statistics.hh
View file

@ -2170,64 +2170,43 @@ class Temp
operator NodePtr() { return node;} operator NodePtr() { return node;}
}; };
} // namespace Detail
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
// //
// Binning Interface // Binning Interface
// //
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
struct MainBin
class BinBase
{ {
private: private:
std::string _name;
char *mem; char *mem;
protected: protected:
off_t memsize; off_t memsize;
off_t size() const { return memsize; } off_t size() const { return memsize; }
char *memory(); char *memory(off_t off);
public: public:
BinBase(); static MainBin *&curBin()
virtual ~BinBase(); {
}; static MainBin *current = NULL;
} // namespace Detail
class GenBin : public Detail::BinBase
{
public:
GenBin() : BinBase() {}
virtual ~GenBin() {};
virtual void activate() = 0;
virtual std::string name() const = 0;
void regBin(GenBin *bin, std::string name);
};
template <class BinType>
struct StatBin : public GenBin
{
private:
std::string _name;
public:
std::string name() const { return _name;}
static StatBin *&curBin() {
static StatBin *current = NULL;
return current; return current;
} }
static void setCurBin(StatBin *bin) { curBin() = bin; } static void setCurBin(MainBin *bin) { curBin() = bin; }
static StatBin *current() { assert(curBin()); return curBin(); } static MainBin *current() { assert(curBin()); return curBin(); }
static off_t &offset() { static off_t &offset()
{
static off_t offset = 0; static off_t offset = 0;
return offset; return offset;
} }
static off_t new_offset(size_t size) { static off_t new_offset(size_t size)
{
size_t mask = sizeof(u_int64_t) - 1; size_t mask = sizeof(u_int64_t) - 1;
off_t off = offset(); off_t off = offset();
@ -2236,23 +2215,24 @@ struct StatBin : public GenBin
return off; return off;
} }
explicit StatBin(std::string name) : GenBin() { _name = name; this->regBin(this, name); } public:
MainBin(const std::string &name);
~MainBin();
char *memory(off_t off) { const std::string &
if (memsize == -1) { name() const
memsize = CeilPow2((size_t) offset()); {
} return _name;
assert(offset() <= size());
return Detail::BinBase::memory() + off;
} }
virtual void activate() { void
activate()
{
setCurBin(this); setCurBin(this);
#ifdef FS_MEASURE #ifdef FS_MEASURE
DPRINTF(TCPIP, "activating %s Bin\n", name()); DPRINTF(TCPIP, "activating %s Bin\n", name());
#endif #endif
} }
static void activate(StatBin &bin) { setCurBin(&bin); }
class BinBase class BinBase
{ {
@ -2261,10 +2241,12 @@ struct StatBin : public GenBin
public: public:
BinBase() : offset(-1) {} BinBase() : offset(-1) {}
void allocate(size_t size) { void allocate(size_t size)
{
offset = new_offset(size); offset = new_offset(size);
} }
char *access() { char *access()
{
assert(offset != -1); assert(offset != -1);
return current()->memory(offset); return current()->memory(offset);
} }
@ -2284,7 +2266,9 @@ struct StatBin : public GenBin
int size() const { return 1; } int size() const { return 1; }
Storage *data(Params &params) { Storage *
data(Params &params)
{
assert(initialized()); assert(initialized());
char *ptr = access(); char *ptr = access();
char *flags = ptr + sizeof(Storage); char *flags = ptr + sizeof(Storage);
@ -2294,7 +2278,9 @@ struct StatBin : public GenBin
} }
return reinterpret_cast<Storage *>(ptr); return reinterpret_cast<Storage *>(ptr);
} }
void reset()
void
reset()
{ {
char *ptr = access(); char *ptr = access();
char *flags = ptr + size() * sizeof(Storage); char *flags = ptr + size() * sizeof(Storage);
@ -2320,7 +2306,8 @@ struct StatBin : public GenBin
VectorBin() : _size(0) {} VectorBin() : _size(0) {}
bool initialized() const { return _size > 0; } bool initialized() const { return _size > 0; }
void init(int s, Params &params) { void init(int s, Params &params)
{
assert(!initialized()); assert(!initialized());
assert(s > 0); assert(s > 0);
_size = s; _size = s;
@ -2329,7 +2316,8 @@ struct StatBin : public GenBin
int size() const { return _size; } int size() const { return _size; }
Storage *data(int index, Params &params) { Storage *data(int index, Params &params)
{
assert(initialized()); assert(initialized());
assert(index >= 0 && index < size()); assert(index >= 0 && index < size());
char *ptr = access(); char *ptr = access();
@ -2357,9 +2345,6 @@ struct StatBin : public GenBin
}; };
}; };
class MainBinType {};
typedef StatBin<MainBinType> MainBin;
struct NoBin struct NoBin
{ {
template <class Storage> template <class Storage>
@ -2379,11 +2364,13 @@ struct NoBin
} }
bool initialized() const { return true; } bool initialized() const { return true; }
void init(Params &params) { void init(Params &params)
{
new (ptr) Storage(params); new (ptr) Storage(params);
} }
int size() const{ return 1; } int size() const{ return 1; }
Storage *data(Params &params) { Storage *data(Params &params)
{
assert(initialized()); assert(initialized());
return reinterpret_cast<Storage *>(ptr); return reinterpret_cast<Storage *>(ptr);
} }
@ -2420,7 +2407,8 @@ struct NoBin
} }
bool initialized() const { return ptr != NULL; } bool initialized() const { return ptr != NULL; }
void init(int s, Params &params) { void init(int s, Params &params)
{
assert(s > 0 && "size must be positive!"); assert(s > 0 && "size must be positive!");
assert(!initialized()); assert(!initialized());
_size = s; _size = s;
@ -2431,7 +2419,8 @@ struct NoBin
int size() const { return _size; } int size() const { return _size; }
Storage *data(int index, Params &params) { Storage *data(int index, Params &params)
{
assert(initialized()); assert(initialized());
assert(index >= 0 && index < size()); assert(index >= 0 && index < size());
return reinterpret_cast<Storage *>(ptr + index * sizeof(Storage)); return reinterpret_cast<Storage *>(ptr + index * sizeof(Storage));

2
kern/tru64/tru64_events.hh
View file

@ -92,7 +92,7 @@ class FnEvent : public PCEvent
private: private:
std::string _name; std::string _name;
Statistics::GenBin *myBin; Statistics::MainBin *myBin;
}; };
#endif //FS_MEASURE #endif //FS_MEASURE
#endif // __TRU64_EVENTS_HH__ #endif // __TRU64_EVENTS_HH__

4
sim/system.cc
View file

@ -105,10 +105,10 @@ printSystems()
} }
#ifdef FS_MEASURE #ifdef FS_MEASURE
Statistics::GenBin * Statistics::MainBin *
System::getBin(const std::string &name) System::getBin(const std::string &name)
{ {
std::map<const std::string, Statistics::GenBin *>::const_iterator i; std::map<const std::string, Statistics::MainBin *>::const_iterator i;
i = fnBins.find(name); i = fnBins.find(name);
if (i == fnBins.end()) if (i == fnBins.end())
panic("trying to getBin that is not on system map!"); panic("trying to getBin that is not on system map!");

4
sim/system.hh
View file

@ -52,7 +52,7 @@ class System : public SimObject
{ {
#ifdef FS_MEASURE #ifdef FS_MEASURE
protected: protected:
std::map<const std::string, Statistics::GenBin *> fnBins; std::map<const std::string, Statistics::MainBin *> fnBins;
std::map<const Addr, SWContext *> swCtxMap; std::map<const Addr, SWContext *> swCtxMap;
#endif //FS_MEASURE #endif //FS_MEASURE
@ -85,7 +85,7 @@ class System : public SimObject
virtual bool breakpoint() = 0; virtual bool breakpoint() = 0;
#ifdef FS_MEASURE #ifdef FS_MEASURE
Statistics::GenBin * getBin(const std::string &name); Statistics::MainBin * getBin(const std::string &name);
virtual bool findCaller(std::string, std::string) const = 0; virtual bool findCaller(std::string, std::string) const = 0;
SWContext *findContext(Addr pcb); SWContext *findContext(Addr pcb);