From 9023f5c96d0a248399fce0f664136d164f0e561f Mon Sep 17 00:00:00 2001 From: Nathan Binkert Date: Fri, 20 Aug 2004 11:35:31 -0400 Subject: - Clean up and factor out all of the binning code into a single place so it's easier to work with. - Add support for binning kernel/user/idle time separately from lisa's binning stuff, but make the two compatible. - KernelStats used to directly implement the pImpl idiom, but it makes more sense to just remove the level of indirection and make the exec context have a pointer to the stats. - Factor common code out of LinuxSystem and Tru64System and put it into the System base class. While doing that, make all constructors take a pointer to a parameter struct instead of naming the parameters individually to make it much easier to add parameters to these classes. SConscript: Move the function tracking and binning stuff around. arch/alpha/ev5.cc: kernelStats is now a pointer arch/alpha/pseudo_inst.cc: kernelStats is now a pointer the parameters to the system have been moved into their own struct base/trace.hh: provide a little functor class for wrapping a string that can allow you to define name() in any scope very simply for use with DPRINTF cpu/base_cpu.cc: New order of arguments for consistency. cpu/exec_context.cc: kernelStats no longer has the level of indirection in it, execContext has the indirection now. so, kernelStats is a pointer. We also need a pointer to the kernelBinning stuff from the system and we need to figure out if we want to do binning or not. Move a whole bunch of code into kern_binning.cc so it's all in the same place. cpu/exec_context.hh: We want pointers to the kernel binning/stats stuff and we'll have the exec_context and system have the level of indirection instead of having the extra layer in the kernel stats class. cpu/simple_cpu/simple_cpu.cc: call through the exec context to do the special binning stuff. kern/kernel_stats.cc: kern/kernel_stats.hh: Re-organize the stats stuff and remove the level of indirection (that was there to simplify building) and move the binning stuff into its own class/file. kern/linux/linux_system.cc: kern/linux/linux_system.hh: kern/tru64/tru64_system.cc: kern/tru64/tru64_system.hh: sim/system.cc: sim/system.hh: move lots of common system code into the base system class so that it can be shared between linux, tru64, and whatever else we decide to support in the future. Make the constructor take a pointer to a parameter struct so that it is easier to pass parameters to the parent. kern/system_events.cc: move the majority of the binning code into the Kernel::Binning class in the kern_binning file kern/system_events.hh: FnEvents only need to know the bin create the Idle start event to find the PCBB of the idle process when it starts. kern/tru64/tru64_events.cc: memCtrl -> memctrl sim/process.cc: sim/process.hh: re-order args for consistency --HG-- extra : convert_revision : 86cb39738c41fcd680f2aad125c9dde000227b2b --- kern/kernel_stats.hh | 158 ++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 144 insertions(+), 14 deletions(-) (limited to 'kern/kernel_stats.hh') diff --git a/kern/kernel_stats.hh b/kern/kernel_stats.hh index 497403762..8339c578c 100644 --- a/kern/kernel_stats.hh +++ b/kern/kernel_stats.hh @@ -29,35 +29,165 @@ #ifndef __KERNEL_STATS_HH__ #define __KERNEL_STATS_HH__ +#include +#include #include +#include + +#include "base/statistics.hh" +#include "sim/serialize.hh" +#include "targetarch/isa_traits.hh" -class KSData; -class ExecContext; class BaseCPU; +class ExecContext; +class FnEvent; enum Fault; -class KernelStats +namespace Kernel { + +enum cpu_mode { kernel, user, idle, cpu_mode_num }; +extern const char *modestr[]; + +class Binning { private: - KSData *data; + std::string myname; + System *system; + + private: + // lisa's binning stuff + struct fnCall + { + Stats::MainBin *myBin; + std::string name; + }; + + struct SWContext + { + Counter calls; + std::stack callStack; + }; + + std::map fnBins; + std::map swCtxMap; + + std::multimap callerMap; + void populateMap(std::string caller, std::string callee); + + std::vector fnEvents; + + Stats::Scalar<> fnCalls; + + Stats::MainBin *getBin(const std::string &name); + bool findCaller(std::string, std::string) const; + + SWContext *findContext(Addr pcb); + bool addContext(Addr pcb, SWContext *ctx) + { + return (swCtxMap.insert(std::make_pair(pcb, ctx))).second; + } + + void remContext(Addr pcb) + { + swCtxMap.erase(pcb); + } + + void dumpState() const; + + SWContext *swctx; + std::vector binned_fns; + + private: + Stats::MainBin *modeBin[3]; + + public: + const bool bin; + const bool fnbin; + + cpu_mode themode; + void palSwapContext(ExecContext *xc); + void execute(ExecContext *xc, const StaticInstBase *inst); + void call(ExecContext *xc, Stats::MainBin *myBin); + void changeMode(cpu_mode mode); public: - KernelStats(ExecContext *_xc, BaseCPU *_cpu); - ~KernelStats(); + Binning(System *sys); + virtual ~Binning(); + const std::string name() const { return myname; } void regStats(const std::string &name); - void arm(); - void quiesce(); - void ivlb(); - void ivle(); - void hwrei(); + public: + virtual void serialize(std::ostream &os); + virtual void unserialize(Checkpoint *cp, const std::string §ion); +}; - void fault(Fault fault); +class Statistics : public Serializable +{ + friend class Binning; + + private: + std::string myname; + ExecContext *xc; + + Addr idleProcess; + cpu_mode themode; + Tick lastModeTick; + + void changeMode(cpu_mode newmode); + + private: + Stats::Scalar<> _arm; + Stats::Scalar<> _quiesce; + Stats::Scalar<> _ivlb; + Stats::Scalar<> _ivle; + Stats::Scalar<> _hwrei; + + Stats::Vector<> _iplCount; + Stats::Vector<> _iplGood; + Stats::Vector<> _iplTicks; + Stats::Formula _iplUsed; + + Stats::Vector<> _callpal; + Stats::Vector<> _syscall; + Stats::Vector<> _faults; + + Stats::Vector<> _mode; + Stats::Vector<> _modeGood; + Stats::Formula _modeFraction; + Stats::Vector<> _modeTicks; + + Stats::Scalar<> _swap_context; + + private: + int iplLast; + Tick iplLastTick; + + public: + Statistics(ExecContext *context); + + const std::string name() const { return myname; } + void regStats(const std::string &name); + + public: + void arm() { _arm++; } + void quiesce() { _quiesce++; } + void ivlb() { _ivlb++; } + void ivle() { _ivle++; } + void hwrei() { _hwrei++; } + void fault(Fault fault) { _faults[fault]++; } void swpipl(int ipl); - void mode(bool user); - void context(Addr old_pcbb, Addr new_pcbb); + void mode(bool usermode); + void context(Addr oldpcbb, Addr newpcbb); void callpal(int code); + + void setIdleProcess(Addr idle); + + public: + virtual void serialize(std::ostream &os); + virtual void unserialize(Checkpoint *cp, const std::string §ion); }; +/* end namespace Kernel */ } + #endif // __KERNEL_STATS_HH__ -- cgit v1.2.3