src/cpu/thread_context.hh

   1 /*
   2  * Copyright (c) 2011-2012 ARM Limited
   3  * Copyright (c) 2013 Advanced Micro Devices, Inc.
   4  * All rights reserved
   5  *
   6  * The license below extends only to copyright in the software and shall
   7  * not be construed as granting a license to any other intellectual
   8  * property including but not limited to intellectual property relating
   9  * to a hardware implementation of the functionality of the software
  10  * licensed hereunder.  You may use the software subject to the license
  11  * terms below provided that you ensure that this notice is replicated
  12  * unmodified and in its entirety in all distributions of the software,
  13  * modified or unmodified, in source code or in binary form.
  14  *
  15  * Copyright (c) 2006 The Regents of The University of Michigan
  16  * All rights reserved.
  17  *
  18  * Redistribution and use in source and binary forms, with or without
  19  * modification, are permitted provided that the following conditions are
  20  * met: redistributions of source code must retain the above copyright
  21  * notice, this list of conditions and the following disclaimer;
  22  * redistributions in binary form must reproduce the above copyright
  23  * notice, this list of conditions and the following disclaimer in the
  24  * documentation and/or other materials provided with the distribution;
  25  * neither the name of the copyright holders nor the names of its
  26  * contributors may be used to endorse or promote products derived from
  27  * this software without specific prior written permission.
  28  *
  29  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  30  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  31  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  32  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  33  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  34  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  35  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  36  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  37  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  38  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  39  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  40  *
  41  * Authors: Kevin Lim
  42  */
  43
  44 #ifndef __CPU_THREAD_CONTEXT_HH__
  45 #define __CPU_THREAD_CONTEXT_HH__
  46
  47 #include <iostream>
  48 #include <string>
  49
  50 #include "arch/registers.hh"
  51 #include "arch/types.hh"
  52 #include "base/types.hh"
  53 #include "config/the_isa.hh"
  54
  55 // @todo: Figure out a more architecture independent way to obtain the ITB and
  56 // DTB pointers.
  57 namespace TheISA
  58 {
  59     class Decoder;
  60     class TLB;
  61 }
  62 class BaseCPU;
  63 class CheckerCPU;
  64 class Checkpoint;
  65 class EndQuiesceEvent;
  66 class SETranslatingPortProxy;
  67 class FSTranslatingPortProxy;
  68 class PortProxy;
  69 class Process;
  70 class System;
  71 namespace TheISA {
  72     namespace Kernel {
  73         class Statistics;
  74     }
  75 }
  76
  77 /**
  78  * ThreadContext is the external interface to all thread state for
  79  * anything outside of the CPU. It provides all accessor methods to
  80  * state that might be needed by external objects, ranging from
  81  * register values to things such as kernel stats. It is an abstract
  82  * base class; the CPU can create its own ThreadContext by either
  83  * deriving from it, or using the templated ProxyThreadContext.
  84  *
  85  * The ThreadContext is slightly different than the ExecContext.  The
  86  * ThreadContext provides access to an individual thread's state; an
  87  * ExecContext provides ISA access to the CPU (meaning it is
  88  * implicitly multithreaded on SMT systems).  Additionally the
  89  * ThreadState is an abstract class that exactly defines the
  90  * interface; the ExecContext is a more implicit interface that must
  91  * be implemented so that the ISA can access whatever state it needs.
  92  */
  93 class ThreadContext
  94 {
  95   protected:
  96     typedef TheISA::MachInst MachInst;
  97     typedef TheISA::IntReg IntReg;
  98     typedef TheISA::FloatReg FloatReg;
  99     typedef TheISA::FloatRegBits FloatRegBits;
 100     typedef TheISA::CCReg CCReg;
 101     typedef TheISA::MiscReg MiscReg;
 102   public:
 103
 104     enum Status
 105     {
 106         /// Running.  Instructions should be executed only when
 107         /// the context is in this state.
 108         Active,
 109
 110         /// Temporarily inactive.  Entered while waiting for
 111         /// synchronization, etc.
 112         Suspended,
 113
 114         /// Permanently shut down.  Entered when target executes
 115         /// m5exit pseudo-instruction.  When all contexts enter
 116         /// this state, the simulation will terminate.
 117         Halted
 118     };
 119
 120     virtual ~ThreadContext() { };
 121
 122     virtual BaseCPU *getCpuPtr() = 0;
 123
 124     virtual int cpuId() const = 0;
 125
 126     virtual uint32_t socketId() const = 0;
 127
 128     virtual int threadId() const = 0;
 129
 130     virtual void setThreadId(int id) = 0;
 131
 132     virtual int contextId() const = 0;
 133
 134     virtual void setContextId(int id) = 0;
 135
 136     virtual TheISA::TLB *getITBPtr() = 0;
 137
 138     virtual TheISA::TLB *getDTBPtr() = 0;
 139
 140     virtual CheckerCPU *getCheckerCpuPtr() = 0;
 141
 142     virtual TheISA::Decoder *getDecoderPtr() = 0;
 143
 144     virtual System *getSystemPtr() = 0;
 145
 146     virtual TheISA::Kernel::Statistics *getKernelStats() = 0;
 147
 148     virtual PortProxy &getPhysProxy() = 0;
 149
 150     virtual FSTranslatingPortProxy &getVirtProxy() = 0;
 151
 152     /**
 153      * Initialise the physical and virtual port proxies and tie them to
 154      * the data port of the CPU.
 155      *
 156      * tc ThreadContext for the virtual-to-physical translation
 157      */
 158     virtual void initMemProxies(ThreadContext *tc) = 0;
 159
 160     virtual SETranslatingPortProxy &getMemProxy() = 0;
 161
 162     virtual Process *getProcessPtr() = 0;
 163
 164     virtual Status status() const = 0;
 165
 166     virtual void setStatus(Status new_status) = 0;
 167
 168     /// Set the status to Active.
 169     virtual void activate() = 0;
 170
 171     /// Set the status to Suspended.
 172     virtual void suspend() = 0;
 173
 174     /// Set the status to Halted.
 175     virtual void halt() = 0;
 176
 177     virtual void dumpFuncProfile() = 0;
 178
 179     virtual void takeOverFrom(ThreadContext *old_context) = 0;
 180
 181     virtual void regStats(const std::string &name) = 0;
 182
 183     virtual EndQuiesceEvent *getQuiesceEvent() = 0;
 184
 185     // Not necessarily the best location for these...
 186     // Having an extra function just to read these is obnoxious
 187     virtual Tick readLastActivate() = 0;
 188     virtual Tick readLastSuspend() = 0;
 189
 190     virtual void profileClear() = 0;
 191     virtual void profileSample() = 0;
 192
 193     virtual void copyArchRegs(ThreadContext *tc) = 0;
 194
 195     virtual void clearArchRegs() = 0;
 196
 197     //
 198     // New accessors for new decoder.
 199     //
 200     virtual uint64_t readIntReg(int reg_idx) = 0;
 201
 202     virtual FloatReg readFloatReg(int reg_idx) = 0;
 203
 204     virtual FloatRegBits readFloatRegBits(int reg_idx) = 0;
 205
 206     virtual CCReg readCCReg(int reg_idx) = 0;
 207
 208     virtual void setIntReg(int reg_idx, uint64_t val) = 0;
 209
 210     virtual void setFloatReg(int reg_idx, FloatReg val) = 0;
 211
 212     virtual void setFloatRegBits(int reg_idx, FloatRegBits val) = 0;
 213
 214     virtual void setCCReg(int reg_idx, CCReg val) = 0;
 215
 216     virtual TheISA::PCState pcState() = 0;
 217
 218     virtual void pcState(const TheISA::PCState &val) = 0;
 219
 220     virtual void pcStateNoRecord(const TheISA::PCState &val) = 0;
 221
 222     virtual Addr instAddr() = 0;
 223
 224     virtual Addr nextInstAddr() = 0;
 225
 226     virtual MicroPC microPC() = 0;
 227
 228     virtual MiscReg readMiscRegNoEffect(int misc_reg) const = 0;
 229
 230     virtual MiscReg readMiscReg(int misc_reg) = 0;
 231
 232     virtual void setMiscRegNoEffect(int misc_reg, const MiscReg &val) = 0;
 233
 234     virtual void setMiscReg(int misc_reg, const MiscReg &val) = 0;
 235
 236     virtual int flattenIntIndex(int reg) = 0;
 237     virtual int flattenFloatIndex(int reg) = 0;
 238     virtual int flattenCCIndex(int reg) = 0;
 239     virtual int flattenMiscIndex(int reg) = 0;
 240
 241     virtual uint64_t
 242     readRegOtherThread(int misc_reg, ThreadID tid)
 243     {
 244         return 0;
 245     }
 246
 247     virtual void
 248     setRegOtherThread(int misc_reg, const MiscReg &val, ThreadID tid)
 249     {
 250     }
 251
 252     // Also not necessarily the best location for these two.  Hopefully will go
 253     // away once we decide upon where st cond failures goes.
 254     virtual unsigned readStCondFailures() = 0;
 255
 256     virtual void setStCondFailures(unsigned sc_failures) = 0;
 257
 258     // Same with st cond failures.
 259     virtual Counter readFuncExeInst() = 0;
 260
 261     virtual void syscall(int64_t callnum) = 0;
 262
 263     // This function exits the thread context in the CPU and returns
 264     // 1 if the CPU has no more active threads (meaning it's OK to exit);
 265     // Used in syscall-emulation mode when a  thread calls the exit syscall.
 266     virtual int exit() { return 1; };
 267
 268     /** function to compare two thread contexts (for debugging) */
 269     static void compare(ThreadContext *one, ThreadContext *two);
 270
 271     /** @{ */
 272     /**
 273      * Flat register interfaces
 274      *
 275      * Some architectures have different registers visible in
 276      * different modes. Such architectures "flatten" a register (see
 277      * flattenIntIndex() and flattenFloatIndex()) to map it into the
 278      * gem5 register file. This interface provides a flat interface to
 279      * the underlying register file, which allows for example
 280      * serialization code to access all registers.
 281      */
 282
 283     virtual uint64_t readIntRegFlat(int idx) = 0;
 284     virtual void setIntRegFlat(int idx, uint64_t val) = 0;
 285
 286     virtual FloatReg readFloatRegFlat(int idx) = 0;
 287     virtual void setFloatRegFlat(int idx, FloatReg val) = 0;
 288
 289     virtual FloatRegBits readFloatRegBitsFlat(int idx) = 0;
 290     virtual void setFloatRegBitsFlat(int idx, FloatRegBits val) = 0;
 291
 292     virtual CCReg readCCRegFlat(int idx) = 0;
 293     virtual void setCCRegFlat(int idx, CCReg val) = 0;
 294     /** @} */
 295
 296 };
 297
 298 /**
 299  * ProxyThreadContext class that provides a way to implement a
 300  * ThreadContext without having to derive from it. ThreadContext is an
 301  * abstract class, so anything that derives from it and uses its
 302  * interface will pay the overhead of virtual function calls.  This
 303  * class is created to enable a user-defined Thread object to be used
 304  * wherever ThreadContexts are used, without paying the overhead of
 305  * virtual function calls when it is used by itself.  See
 306  * simple_thread.hh for an example of this.
 307  */
 308 template <class TC>
 309 class ProxyThreadContext : public ThreadContext
 310 {
 311   public:
 312     ProxyThreadContext(TC *actual_tc)
 313     { actualTC = actual_tc; }
 314
 315   private:
 316     TC *actualTC;
 317
 318   public:
 319
 320     BaseCPU *getCpuPtr() { return actualTC->getCpuPtr(); }
 321
 322     int cpuId() const { return actualTC->cpuId(); }
 323
 324     uint32_t socketId() const { return actualTC->socketId(); }
 325
 326     int threadId() const { return actualTC->threadId(); }
 327
 328     void setThreadId(int id) { actualTC->setThreadId(id); }
 329
 330     int contextId() const { return actualTC->contextId(); }
 331
 332     void setContextId(int id) { actualTC->setContextId(id); }
 333
 334     TheISA::TLB *getITBPtr() { return actualTC->getITBPtr(); }
 335
 336     TheISA::TLB *getDTBPtr() { return actualTC->getDTBPtr(); }
 337
 338     CheckerCPU *getCheckerCpuPtr() { return actualTC->getCheckerCpuPtr(); }
 339
 340     TheISA::Decoder *getDecoderPtr() { return actualTC->getDecoderPtr(); }
 341
 342     System *getSystemPtr() { return actualTC->getSystemPtr(); }
 343
 344     TheISA::Kernel::Statistics *getKernelStats()
 345     { return actualTC->getKernelStats(); }
 346
 347     PortProxy &getPhysProxy() { return actualTC->getPhysProxy(); }
 348
 349     FSTranslatingPortProxy &getVirtProxy() { return actualTC->getVirtProxy(); }
 350
 351     void initMemProxies(ThreadContext *tc) { actualTC->initMemProxies(tc); }
 352
 353     SETranslatingPortProxy &getMemProxy() { return actualTC->getMemProxy(); }
 354
 355     Process *getProcessPtr() { return actualTC->getProcessPtr(); }
 356
 357     Status status() const { return actualTC->status(); }
 358
 359     void setStatus(Status new_status) { actualTC->setStatus(new_status); }
 360
 361     /// Set the status to Active.
 362     void activate() { actualTC->activate(); }
 363
 364     /// Set the status to Suspended.
 365     void suspend() { actualTC->suspend(); }
 366
 367     /// Set the status to Halted.
 368     void halt() { actualTC->halt(); }
 369
 370     void dumpFuncProfile() { actualTC->dumpFuncProfile(); }
 371
 372     void takeOverFrom(ThreadContext *oldContext)
 373     { actualTC->takeOverFrom(oldContext); }
 374
 375     void regStats(const std::string &name) { actualTC->regStats(name); }
 376
 377     EndQuiesceEvent *getQuiesceEvent() { return actualTC->getQuiesceEvent(); }
 378
 379     Tick readLastActivate() { return actualTC->readLastActivate(); }
 380     Tick readLastSuspend() { return actualTC->readLastSuspend(); }
 381
 382     void profileClear() { return actualTC->profileClear(); }
 383     void profileSample() { return actualTC->profileSample(); }
 384
 385     // @todo: Do I need this?
 386     void copyArchRegs(ThreadContext *tc) { actualTC->copyArchRegs(tc); }
 387
 388     void clearArchRegs() { actualTC->clearArchRegs(); }
 389
 390     //
 391     // New accessors for new decoder.
 392     //
 393     uint64_t readIntReg(int reg_idx)
 394     { return actualTC->readIntReg(reg_idx); }
 395
 396     FloatReg readFloatReg(int reg_idx)
 397     { return actualTC->readFloatReg(reg_idx); }
 398
 399     FloatRegBits readFloatRegBits(int reg_idx)
 400     { return actualTC->readFloatRegBits(reg_idx); }
 401
 402     CCReg readCCReg(int reg_idx)
 403     { return actualTC->readCCReg(reg_idx); }
 404
 405     void setIntReg(int reg_idx, uint64_t val)
 406     { actualTC->setIntReg(reg_idx, val); }
 407
 408     void setFloatReg(int reg_idx, FloatReg val)
 409     { actualTC->setFloatReg(reg_idx, val); }
 410
 411     void setFloatRegBits(int reg_idx, FloatRegBits val)
 412     { actualTC->setFloatRegBits(reg_idx, val); }
 413
 414     void setCCReg(int reg_idx, CCReg val)
 415     { actualTC->setCCReg(reg_idx, val); }
 416
 417     TheISA::PCState pcState() { return actualTC->pcState(); }
 418
 419     void pcState(const TheISA::PCState &val) { actualTC->pcState(val); }
 420
 421     void pcStateNoRecord(const TheISA::PCState &val) { actualTC->pcState(val); }
 422
 423     Addr instAddr() { return actualTC->instAddr(); }
 424     Addr nextInstAddr() { return actualTC->nextInstAddr(); }
 425     MicroPC microPC() { return actualTC->microPC(); }
 426
 427     bool readPredicate() { return actualTC->readPredicate(); }
 428
 429     void setPredicate(bool val)
 430     { actualTC->setPredicate(val); }
 431
 432     MiscReg readMiscRegNoEffect(int misc_reg) const
 433     { return actualTC->readMiscRegNoEffect(misc_reg); }
 434
 435     MiscReg readMiscReg(int misc_reg)
 436     { return actualTC->readMiscReg(misc_reg); }
 437
 438     void setMiscRegNoEffect(int misc_reg, const MiscReg &val)
 439     { return actualTC->setMiscRegNoEffect(misc_reg, val); }
 440
 441     void setMiscReg(int misc_reg, const MiscReg &val)
 442     { return actualTC->setMiscReg(misc_reg, val); }
 443
 444     int flattenIntIndex(int reg)
 445     { return actualTC->flattenIntIndex(reg); }
 446
 447     int flattenFloatIndex(int reg)
 448     { return actualTC->flattenFloatIndex(reg); }
 449
 450     int flattenCCIndex(int reg)
 451     { return actualTC->flattenCCIndex(reg); }
 452
 453     int flattenMiscIndex(int reg)
 454     { return actualTC->flattenMiscIndex(reg); }
 455
 456     unsigned readStCondFailures()
 457     { return actualTC->readStCondFailures(); }
 458
 459     void setStCondFailures(unsigned sc_failures)
 460     { actualTC->setStCondFailures(sc_failures); }
 461
 462     void syscall(int64_t callnum)
 463     { actualTC->syscall(callnum); }
 464
 465     Counter readFuncExeInst() { return actualTC->readFuncExeInst(); }
 466
 467     uint64_t readIntRegFlat(int idx)
 468     { return actualTC->readIntRegFlat(idx); }
 469
 470     void setIntRegFlat(int idx, uint64_t val)
 471     { actualTC->setIntRegFlat(idx, val); }
 472
 473     FloatReg readFloatRegFlat(int idx)
 474     { return actualTC->readFloatRegFlat(idx); }
 475
 476     void setFloatRegFlat(int idx, FloatReg val)
 477     { actualTC->setFloatRegFlat(idx, val); }
 478
 479     FloatRegBits readFloatRegBitsFlat(int idx)
 480     { return actualTC->readFloatRegBitsFlat(idx); }
 481
 482     void setFloatRegBitsFlat(int idx, FloatRegBits val)
 483     { actualTC->setFloatRegBitsFlat(idx, val); }
 484
 485     CCReg readCCRegFlat(int idx)
 486     { return actualTC->readCCRegFlat(idx); }
 487
 488     void setCCRegFlat(int idx, CCReg val)
 489     { actualTC->setCCRegFlat(idx, val); }
 490 };
 491
 492 /** @{ */
 493 /**
 494  * Thread context serialization helpers
 495  *
 496  * These helper functions provide a way to the data in a
 497  * ThreadContext. They are provided as separate helper function since
 498  * implementing them as members of the ThreadContext interface would
 499  * be confusing when the ThreadContext is exported via a proxy.
 500  */
 501
 502 void serialize(ThreadContext &tc, std::ostream &os);
 503 void unserialize(ThreadContext &tc, Checkpoint *cp, const std::string &section);
 504
 505 /** @} */
 506
 507
 508 /**
 509  * Copy state between thread contexts in preparation for CPU handover.
 510  *
 511  * @note This method modifies the old thread contexts as well as the
 512  * new thread context. The old thread context will have its quiesce
 513  * event descheduled if it is scheduled and its status set to halted.
 514  *
 515  * @param new_tc Destination ThreadContext.
 516  * @param old_tc Source ThreadContext.
 517  */
 518 void takeOverFrom(ThreadContext &new_tc, ThreadContext &old_tc);
 519
 520 #endif