src/sim/workload.hh

   1 /*
   2  * Copyright 2019 Google Inc.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met: redistributions of source code must retain the above copyright
   7  * notice, this list of conditions and the following disclaimer;
   8  * redistributions in binary form must reproduce the above copyright
   9  * notice, this list of conditions and the following disclaimer in the
  10  * documentation and/or other materials provided with the distribution;
  11  * neither the name of the copyright holders nor the names of its
  12  * contributors may be used to endorse or promote products derived from
  13  * this software without specific prior written permission.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  17  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  18  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  19  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  21  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #ifndef __SIM_WORKLOAD_HH__
  29 #define __SIM_WORKLOAD_HH__
  30
  31 #include "base/loader/object_file.hh"
  32 #include "base/loader/symtab.hh"
  33 #include "params/Workload.hh"
  34 #include "sim/sim_object.hh"
  35 #include "sim/stats.hh"
  36
  37 class System;
  38 class ThreadContext;
  39
  40 class Workload : public SimObject
  41 {
  42   protected:
  43     virtual Addr fixFuncEventAddr(Addr addr) const { return addr; }
  44
  45     struct WorkloadStats : public Stats::Group
  46     {
  47         Stats::Scalar arm;
  48         Stats::Scalar quiesce;
  49
  50         WorkloadStats(Workload *workload) : Stats::Group(workload),
  51             arm(this, "inst.arm", "number of arm instructions executed"),
  52             quiesce(this, "inst.quiesce",
  53                     "number of quiesce instructions executed")
  54         {}
  55     } stats;
  56
  57   public:
  58     Workload(const WorkloadParams &_params) : SimObject(_params), stats(this)
  59     {}
  60
  61     void recordQuiesce() { stats.quiesce++; }
  62     void recordArm() { stats.arm++; }
  63
  64     System *system = nullptr;
  65
  66     virtual Addr getEntry() const = 0;
  67     virtual Loader::Arch getArch() const = 0;
  68
  69     virtual const Loader::SymbolTable &symtab(ThreadContext *tc) = 0;
  70     virtual bool insertSymbol(const Loader::Symbol &symbol) = 0;
  71
  72     virtual void
  73     syscall(ThreadContext *tc)
  74     {
  75         panic("syscall() not implemented.");
  76     }
  77
  78     /** @{ */
  79     /**
  80      * Add a function-based event to the given function, to be looked
  81      * up in the specified symbol table.
  82      *
  83      * The ...OrPanic flavor of the method causes the simulator to
  84      * panic if the symbol can't be found.
  85      *
  86      * @param symtab Symbol table to use for look up.
  87      * @param lbl Function to hook the event to.
  88      * @param desc Description to be passed to the event.
  89      * @param args Arguments to be forwarded to the event constructor.
  90      */
  91     template <class T, typename... Args>
  92     T *
  93     addFuncEvent(const Loader::SymbolTable &symtab, const char *lbl,
  94                  const std::string &desc, Args... args)
  95     {
  96         auto it = symtab.find(lbl);
  97         if (it == symtab.end())
  98             return nullptr;
  99
 100         return new T(system, desc, fixFuncEventAddr(it->address),
 101                       std::forward<Args>(args)...);
 102     }
 103
 104     template <class T>
 105     T *
 106     addFuncEvent(const Loader::SymbolTable &symtab, const char *lbl)
 107     {
 108         return addFuncEvent<T>(symtab, lbl, lbl);
 109     }
 110
 111     template <class T, typename... Args>
 112     T *
 113     addFuncEventOrPanic(const Loader::SymbolTable &symtab, const char *lbl,
 114                         Args... args)
 115     {
 116         T *e = addFuncEvent<T>(symtab, lbl, std::forward<Args>(args)...);
 117         panic_if(!e, "Failed to find symbol '%s'", lbl);
 118         return e;
 119     }
 120     /** @} */
 121 };
 122
 123 #endif // __SIM_WORKLOAD_HH__