src/sim/system.hh

   1 /*
   2  * Copyright (c) 2002-2005 The Regents of The University of Michigan
   3  * Copyright (c) 2011 Regents of the University of California
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are
   8  * met: redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer;
  10  * redistributions in binary form must reproduce the above copyright
  11  * notice, this list of conditions and the following disclaimer in the
  12  * documentation and/or other materials provided with the distribution;
  13  * neither the name of the copyright holders nor the names of its
  14  * contributors may be used to endorse or promote products derived from
  15  * this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * Authors: Steve Reinhardt
  30  *          Lisa Hsu
  31  *          Nathan Binkert
  32  *          Rick Strong
  33  */
  34
  35 #ifndef __SYSTEM_HH__
  36 #define __SYSTEM_HH__
  37
  38 #include <string>
  39 #include <vector>
  40
  41 #include "base/loader/symtab.hh"
  42 #include "base/misc.hh"
  43 #include "base/statistics.hh"
  44 #include "config/full_system.hh"
  45 #include "cpu/pc_event.hh"
  46 #include "enums/MemoryMode.hh"
  47 #include "mem/port.hh"
  48 #include "params/System.hh"
  49 #include "sim/sim_object.hh"
  50
  51 #if FULL_SYSTEM
  52 #include "kern/system_events.hh"
  53 #endif
  54
  55 class BaseCPU;
  56 class ThreadContext;
  57 class ObjectFile;
  58 class PhysicalMemory;
  59
  60 #if FULL_SYSTEM
  61 class Platform;
  62 class FunctionalPort;
  63 class VirtualPort;
  64 #endif
  65 class GDBListener;
  66 class BaseRemoteGDB;
  67
  68 class System : public SimObject
  69 {
  70   public:
  71
  72     static const char *MemoryModeStrings[3];
  73
  74     Enums::MemoryMode
  75     getMemoryMode()
  76     {
  77         assert(memoryMode);
  78         return memoryMode;
  79     }
  80
  81     /** Change the memory mode of the system. This should only be called by the
  82      * python!!
  83      * @param mode Mode to change to (atomic/timing)
  84      */
  85     void setMemoryMode(Enums::MemoryMode mode);
  86
  87     PhysicalMemory *physmem;
  88     PCEventQueue pcEventQueue;
  89
  90     std::vector<ThreadContext *> threadContexts;
  91     int _numContexts;
  92
  93     ThreadContext *getThreadContext(ThreadID tid)
  94     {
  95         return threadContexts[tid];
  96     }
  97
  98     int numContexts()
  99     {
 100         assert(_numContexts == (int)threadContexts.size());
 101         return _numContexts;
 102     }
 103
 104     /** Return number of running (non-halted) thread contexts in
 105      * system.  These threads could be Active or Suspended. */
 106     int numRunningContexts();
 107
 108     /** List to store ranges of memories in this system */
 109     AddrRangeList memRanges;
 110
 111     /** check if an address points to valid system memory
 112      * and thus we can fetch instructions out of it
 113      */
 114     bool isMemory(const Addr addr) const;
 115
 116 #if FULL_SYSTEM
 117     Platform *platform;
 118     uint64_t init_param;
 119
 120     /** Port to physical memory used for writing object files into ram at
 121      * boot.*/
 122     FunctionalPort *functionalPort;
 123     VirtualPort *virtPort;
 124
 125     /** kernel symbol table */
 126     SymbolTable *kernelSymtab;
 127
 128     /** Object pointer for the kernel code */
 129     ObjectFile *kernel;
 130
 131     /** Begining of kernel code */
 132     Addr kernelStart;
 133
 134     /** End of kernel code */
 135     Addr kernelEnd;
 136
 137     /** Entry point in the kernel to start at */
 138     Addr kernelEntry;
 139
 140     /** Mask that should be anded for binary/symbol loading.
 141      * This allows one two different OS requirements for the same ISA to be
 142      * handled.  Some OSes are compiled for a virtual address and need to be
 143      * loaded into physical memory that starts at address 0, while other
 144      * bare metal tools generate images that start at address 0.
 145      */
 146     Addr loadAddrMask;
 147
 148 #else
 149
 150     Addr pagePtr;
 151
 152   protected:
 153     uint64_t nextPID;
 154
 155   public:
 156     uint64_t allocatePID()
 157     {
 158         return nextPID++;
 159     }
 160
 161     /** Amount of physical memory that is still free */
 162     Addr freeMemSize();
 163
 164     /** Amount of physical memory that exists */
 165     Addr memSize();
 166
 167
 168 #endif // FULL_SYSTEM
 169
 170   protected:
 171     Enums::MemoryMode memoryMode;
 172     uint64_t workItemsBegin;
 173     uint64_t workItemsEnd;
 174     uint32_t numWorkIds;
 175     std::vector<bool> activeCpus;
 176
 177   public:
 178     virtual void regStats();
 179     /**
 180      * Called by pseudo_inst to track the number of work items started by this
 181      * system.
 182      */
 183     uint64_t
 184     incWorkItemsBegin()
 185     {
 186         return ++workItemsBegin;
 187     }
 188
 189     /**
 190      * Called by pseudo_inst to track the number of work items completed by
 191      * this system.
 192      */
 193     uint64_t
 194     incWorkItemsEnd()
 195     {
 196         return ++workItemsEnd;
 197     }
 198
 199     /**
 200      * Called by pseudo_inst to mark the cpus actively executing work items.
 201      * Returns the total number of cpus that have executed work item begin or
 202      * ends.
 203      */
 204     int
 205     markWorkItem(int index)
 206     {
 207         int count = 0;
 208         assert(index < activeCpus.size());
 209         activeCpus[index] = true;
 210         for (std::vector<bool>::iterator i = activeCpus.begin();
 211              i < activeCpus.end(); i++) {
 212             if (*i) count++;
 213         }
 214         return count;
 215     }
 216
 217     inline void workItemBegin(uint32_t tid, uint32_t workid)
 218     {
 219         std::pair<uint32_t,uint32_t> p(tid, workid);
 220         lastWorkItemStarted[p] = curTick();
 221     }
 222
 223     void workItemEnd(uint32_t tid, uint32_t workid);
 224
 225 #if FULL_SYSTEM
 226     /**
 227      * Fix up an address used to match PCs for hooking simulator
 228      * events on to target function executions.  See comment in
 229      * system.cc for details.
 230      */
 231     virtual Addr fixFuncEventAddr(Addr addr) = 0;
 232
 233     /**
 234      * Add a function-based event to the given function, to be looked
 235      * up in the specified symbol table.
 236      */
 237     template <class T>
 238     T *addFuncEvent(SymbolTable *symtab, const char *lbl)
 239     {
 240         Addr addr = 0; // initialize only to avoid compiler warning
 241
 242         if (symtab->findAddress(lbl, addr)) {
 243             T *ev = new T(&pcEventQueue, lbl, fixFuncEventAddr(addr));
 244             return ev;
 245         }
 246
 247         return NULL;
 248     }
 249
 250     /** Add a function-based event to kernel code. */
 251     template <class T>
 252     T *addKernelFuncEvent(const char *lbl)
 253     {
 254         return addFuncEvent<T>(kernelSymtab, lbl);
 255     }
 256
 257 #endif
 258   public:
 259     std::vector<BaseRemoteGDB *> remoteGDB;
 260     std::vector<GDBListener *> gdbListen;
 261     bool breakpoint();
 262
 263   public:
 264     typedef SystemParams Params;
 265
 266   protected:
 267     Params *_params;
 268
 269   public:
 270     System(Params *p);
 271     ~System();
 272
 273     void initState();
 274
 275     const Params *params() const { return (const Params *)_params; }
 276
 277   public:
 278
 279 #if FULL_SYSTEM
 280     /**
 281      * Returns the addess the kernel starts at.
 282      * @return address the kernel starts at
 283      */
 284     Addr getKernelStart() const { return kernelStart; }
 285
 286     /**
 287      * Returns the addess the kernel ends at.
 288      * @return address the kernel ends at
 289      */
 290     Addr getKernelEnd() const { return kernelEnd; }
 291
 292     /**
 293      * Returns the addess the entry point to the kernel code.
 294      * @return entry point of the kernel code
 295      */
 296     Addr getKernelEntry() const { return kernelEntry; }
 297
 298 #else
 299
 300     /// Allocate npages contiguous unused physical pages
 301     /// @return Starting address of first page
 302     Addr allocPhysPages(int npages);
 303
 304 #endif // FULL_SYSTEM
 305
 306     int registerThreadContext(ThreadContext *tc, int assigned=-1);
 307     void replaceThreadContext(ThreadContext *tc, int context_id);
 308
 309     void serialize(std::ostream &os);
 310     void unserialize(Checkpoint *cp, const std::string &section);
 311     virtual void resume();
 312
 313   public:
 314     Counter totalNumInsts;
 315     EventQueue instEventQueue;
 316     std::map<std::pair<uint32_t,uint32_t>, Tick>  lastWorkItemStarted;
 317     std::map<uint32_t, Stats::Histogram*> workItemStats;
 318
 319     ////////////////////////////////////////////
 320     //
 321     // STATIC GLOBAL SYSTEM LIST
 322     //
 323     ////////////////////////////////////////////
 324
 325     static std::vector<System *> systemList;
 326     static int numSystemsRunning;
 327
 328     static void printSystems();
 329
 330
 331 };
 332
 333 #endif // __SYSTEM_HH__