Timing.h

Go to the documentation of this file.

 
#ifndef ETISS_TIMING_H
#define ETISS_TIMING_H
 
#include "etiss/Instruction.h"
#include "etiss/Misc.h"
#include "etiss/Plugin.h"
 
#include <functional>
#include <regex>
 
namespace etiss
{
 
class DataSheetAccurateTiming : public TranslationPlugin
{
  private:
    struct Rule
    {
        std::function<bool(uint32_t /*mode*/)> mode;
        std::function<bool(unsigned /*width*/)> width;
        std::function<bool(etiss::instr::Instruction & /*instr*/)> instr;
        std::function<void(etiss::instr::Instruction &)> handler;
    };
    struct Rule {…};
 
  public:
    void addRule(std::function<bool(uint32_t /*mode*/)> matchesMode,
                 std::function<bool(unsigned /*width*/)> matchesWidth,
                 std::function<bool(etiss::instr::Instruction & /*instr*/)> matchesInstr,
                 std::function<void(etiss::instr::Instruction & /*match*/)> handleMatch);
    void addRule(const std::tuple<uint32_t, unsigned, const char *,
                                  std::function<void(etiss::instr::Instruction & /*match*/)>> &tuple);
    void addRule(const std::tuple<std::regex, std::regex, std::regex,
                                  std::function<void(etiss::instr::Instruction & /*match*/)>> &tuple);
    inline void addRule(
        const std::tuple<std::regex, std::regex, std::regex, void (*)(etiss::instr::Instruction & /*match*/)> &tuple)
    {
        addRule(make_tuple(std::get<0>(tuple), std::get<1>(tuple), std::get<2>(tuple),
                           std::function<void(etiss::instr::Instruction &)>(std::get<3>(tuple))));
    }
    inline void addRule( {…}
 
    template <unsigned cycles, bool isNotAdditionalTime = true>
    static void handleMatch_cycles(etiss::instr::Instruction &instr)
    {
        static_assert((cycles > 0) || (!isNotAdditionalTime),
                      "etiss::DataSheetAccurateTiming::handleMatch_cycles may not be used with cycle = 0 and "
                      "isNoteAdditionalTime = false");
        std::string code;
        if (cycles == 1)
        {
            code = "cpu->cpuTime_ps += cpu->cpuCycleTime_ps; //DataSheetAccurateTiming\n";
        }
        else
        {
            code = std::string("cpu->cpuTime_ps += ") + etiss::toString(cycles) +
                   " * cpu->cpuCycleTime_ps; //DataSheetAccurateTiming\n";
        }
        instr.addCallback(
            [code](etiss::instr::BitArray &ba, etiss::CodeSet &cs, etiss::instr::InstructionContext &ic) {
                CodePart &cp = cs.prepend(CodePart::INITIALREQUIRED);
                cp.getAffectedRegisters().add("cpuTime_ps", 64);
                cp.code() = code;
 
                return true;
            },
            isNotAdditionalTime ? ((uint32_t)etiss::instr::Instruction::BUILTINGROUP::CPUTIMEUPDATE) : 0);
    }
    static void handleMatch_cycles(etiss::instr::Instruction &instr) {…}
 
  private:
    inline void ctor_hlpr() {}
    template <typename A, typename... T>
    void ctor_hlpr(const A &arg, const T &... rules)
    {
        addRule(arg); // store current element
        ctor_hlpr(rules...);
    }
    void ctor_hlpr(const A &arg, const T &... rules) {…}
 
  public:
    const std::string name_;
    template <typename... T>
    DataSheetAccurateTiming(const std::string &name, const T &... rules) : name_(name)
    {
        ctor_hlpr(rules...);
    }
    DataSheetAccurateTiming(const std::string &name, const T &... rules) : name_(name) {…}
    virtual ~DataSheetAccurateTiming();
 
    virtual void initInstrSet(etiss::instr::ModedInstructionSet &) const;
 
  protected:
    inline std::string _getPluginName() const { return name_; }
 
  private:
    std::list<Rule *> rules_;
};
class DataSheetAccurateTiming : public TranslationPlugin {…};
 
} // namespace etiss
 
#endif // ETISS_TIMING_H