[02/19] Backend: Add StoreProfiling and CalcTimestamp instructions

Submitted by junyan.he@inbox.com on Sept. 9, 2015, midnight

Details

Message ID 1441756870-32320-3-git-send-email-junyan.he@inbox.com
State New
Headers show

Not browsing as part of any series.

Commit Message

junyan.he@inbox.com Sept. 9, 2015, midnight
From: Junyan He <junyan.he@linux.intel.com>

Add two instructions for profiling usage. CalcTimestamp will
calculate the timestamps and update the timestamp in the
according slot. StoreProfiling will store the information
to buffer and generate logs.

Signed-off-by: Junyan He <junyan.he@linux.intel.com>
---
 backend/src/ir/instruction.cpp |   96 +++++++++++++++++++++++++++++++++++++++-
 backend/src/ir/instruction.hpp |   26 +++++++++++
 backend/src/ir/instruction.hxx |    2 +
 3 files changed, 123 insertions(+), 1 deletion(-)

Patch hide | download patch | download mbox

diff --git a/backend/src/ir/instruction.cpp b/backend/src/ir/instruction.cpp
index f93c528..280c60d 100644
--- a/backend/src/ir/instruction.cpp
+++ b/backend/src/ir/instruction.cpp
@@ -677,6 +677,58 @@  namespace ir {
       static const uint32_t dstNum = 1;
     };
 
+    class ALIGNED_INSTRUCTION CalcTimestampInstruction :
+      public BasePolicy,
+      public NSrcPolicy<CalcTimestampInstruction, 0>,
+      public NDstPolicy<CalcTimestampInstruction, 0>
+    {
+    public:
+      CalcTimestampInstruction(uint32_t pointNum, uint32_t timestampType) {
+        this->opcode = OP_CALC_TIMESTAMP;
+        this->timestampType = static_cast<uint8_t>(timestampType);
+        this->pointNum = static_cast<uint8_t>(pointNum);
+      }
+
+      INLINE bool wellFormed(const Function &fn, std::string &why) const;
+      INLINE void out(std::ostream &out, const Function &fn) const {
+        this->outOpcode(out);
+        out << "TimeStamp pointer " << static_cast<uint32_t>(pointNum)
+          << " (Type " << static_cast<uint32_t>(timestampType) << ")";
+      }
+      uint32_t getPointNum(void) const { return this->pointNum; }
+      uint32_t getTimestamptType(void) const { return this->timestampType; }
+      uint8_t timestampType;       //!< Type of the time stamp, 16bits or 32bits, eg.
+      uint8_t pointNum;            //!< The insert point number.
+      Register dst[0], src[0];
+    };
+
+    class ALIGNED_INSTRUCTION StoreProfilingInstruction :
+      public BasePolicy,
+      public NSrcPolicy<StoreProfilingInstruction, 0>,
+      public NDstPolicy<StoreProfilingInstruction, 0>
+    {
+    public:
+      StoreProfilingInstruction(uint32_t bti, uint32_t profilingType) {
+        this->opcode = OP_STORE_PROFILING;
+        this->profilingType = static_cast<uint8_t>(profilingType);
+        this->bti = static_cast<uint8_t>(bti);
+      }
+
+      INLINE bool wellFormed(const Function &fn, std::string &why) const;
+      INLINE void out(std::ostream &out, const Function &fn) const {
+        this->outOpcode(out);
+        out << " BTI " << static_cast<uint32_t>(this->bti)
+          << " (Type " << static_cast<uint32_t>(this->profilingType) << ")";
+      }
+
+      uint32_t getProfilingType(void) const { return this->profilingType; }
+      uint32_t getBTI(void) const { return this->bti; }
+      uint8_t profilingType;     //!< Type format of profiling, 16bits or 32bits, eg.
+      uint8_t bti;
+      Register src[0];
+      Register dst[0];
+    };
+
     class ALIGNED_INSTRUCTION LoadImmInstruction :
       public BasePolicy,
       public NSrcPolicy<LoadImmInstruction, 0>,
@@ -1226,6 +1278,26 @@  namespace ir {
       return true;
     }
 
+    INLINE bool CalcTimestampInstruction::wellFormed(const Function &fn, std::string &whyNot) const {
+      if (UNLIKELY(this->timestampType != 1)) {
+        whyNot = "Wrong time stamp type";
+        return false;
+      }
+      if (UNLIKELY(this->pointNum >= 20 && this->pointNum != 0xff && this->pointNum != 0xfe)) {
+        whyNot = "To much Insert pointer";
+        return false;
+      }
+      return true;
+    }
+
+    INLINE bool StoreProfilingInstruction::wellFormed(const Function &fn, std::string &whyNot) const {
+      if (UNLIKELY(this->profilingType != 1)) {
+        whyNot = "Wrong profiling format";
+        return false;
+      }
+      return true;
+    }
+
 #undef CHECK_TYPE
 
     /////////////////////////////////////////////////////////////////////////
@@ -1466,6 +1538,14 @@  START_INTROSPECTION(GetImageInfoInstruction)
 #include "ir/instruction.hxx"
 END_INTROSPECTION(GetImageInfoInstruction)
 
+START_INTROSPECTION(CalcTimestampInstruction)
+#include "ir/instruction.hxx"
+END_INTROSPECTION(CalcTimestampInstruction)
+
+START_INTROSPECTION(StoreProfilingInstruction)
+#include "ir/instruction.hxx"
+END_INTROSPECTION(StoreProfilingInstruction)
+
 START_INTROSPECTION(LoadImmInstruction)
 #include "ir/instruction.hxx"
 END_INTROSPECTION(LoadImmInstruction)
@@ -1645,7 +1725,9 @@  END_FUNCTION(Instruction, Register)
     return opcode == OP_STORE ||
            opcode == OP_TYPED_WRITE ||
            opcode == OP_SYNC ||
-           opcode == OP_ATOMIC;
+           opcode == OP_ATOMIC ||
+           opcode == OP_CALC_TIMESTAMP ||
+           opcode == OP_STORE_PROFILING;
   }
 
 #define DECL_MEM_FN(CLASS, RET, PROTOTYPE, CALL) \
@@ -1699,6 +1781,10 @@  DECL_MEM_FN(TypedWriteInstruction, Type, getCoordType(void), getCoordType())
 DECL_MEM_FN(TypedWriteInstruction, uint8_t, getImageIndex(void), getImageIndex())
 DECL_MEM_FN(GetImageInfoInstruction, uint32_t, getInfoType(void), getInfoType())
 DECL_MEM_FN(GetImageInfoInstruction, uint8_t, getImageIndex(void), getImageIndex())
+DECL_MEM_FN(CalcTimestampInstruction, uint32_t, getPointNum(void), getPointNum())
+DECL_MEM_FN(CalcTimestampInstruction, uint32_t, getTimestamptType(void), getTimestamptType())
+DECL_MEM_FN(StoreProfilingInstruction, uint32_t, getProfilingType(void), getProfilingType())
+DECL_MEM_FN(StoreProfilingInstruction, uint32_t, getBTI(void), getBTI())
 
 #undef DECL_MEM_FN
 
@@ -1940,6 +2026,14 @@  DECL_MEM_FN(GetImageInfoInstruction, uint8_t, getImageIndex(void), getImageIndex
     return internal::GetImageInfoInstruction(infoType, dst, imageIndex, infoReg).convert();
   }
 
+  Instruction CALC_TIMESTAMP(uint32_t pointNum, uint32_t tsType) {
+    return internal::CalcTimestampInstruction(pointNum, tsType).convert();
+  }
+
+  Instruction STORE_PROFILING(uint32_t bti, uint32_t profilingType) {
+    return internal::StoreProfilingInstruction(bti, profilingType).convert();
+  }
+
   std::ostream &operator<< (std::ostream &out, const Instruction &insn) {
     const Function &fn = insn.getFunction();
     const BasicBlock *bb = insn.getParent();
diff --git a/backend/src/ir/instruction.hpp b/backend/src/ir/instruction.hpp
index cf8d839..615ee55 100644
--- a/backend/src/ir/instruction.hpp
+++ b/backend/src/ir/instruction.hpp
@@ -440,6 +440,28 @@  namespace ir {
     static bool isClassOf(const Instruction &insn);
   };
 
+  /*! calculate the exec time and store it. */
+  class CalcTimestampInstruction : public Instruction {
+  public:
+    /*! Return true if the given instruction is an instance of this class */
+    static bool isClassOf(const Instruction &insn);
+    /*! Get the point number of timestamp point */
+    uint32_t getPointNum(void) const;
+    /*! Get the timestamp type */
+    uint32_t getTimestamptType(void) const;
+  };
+
+  /*! store the profiling information. */
+  class StoreProfilingInstruction : public Instruction {
+  public:
+    /*! Return true if the given instruction is an instance of this class */
+    static bool isClassOf(const Instruction &insn);
+    /*! Get the profiling info type */
+    uint32_t getProfilingType(void) const;
+    /*! Get the BTI index*/
+    uint32_t getBTI(void) const;
+  };
+
   /*! Branch instruction is the unified way to branch (with or without
    *  predicate)
    */
@@ -757,6 +779,10 @@  namespace ir {
   Instruction SAMPLE(uint8_t imageIndex, Tuple dst, Tuple src, uint8_t srcNum, bool dstIsFloat, bool srcIsFloat, uint8_t sampler, uint8_t samplerOffset);
   /*! get image information , such as width/height/depth/... */
   Instruction GET_IMAGE_INFO(int infoType, Register dst, uint8_t imageIndex, Register infoReg);
+  /*! calculate the execute timestamp for profiling */
+  Instruction CALC_TIMESTAMP(uint32_t pointNum, uint32_t tsType);
+  /*! calculate the execute timestamp for profiling */
+  Instruction STORE_PROFILING(uint32_t bti, uint32_t Type);
   /*! label labelIndex */
   Instruction LABEL(LabelIndex labelIndex);
 
diff --git a/backend/src/ir/instruction.hxx b/backend/src/ir/instruction.hxx
index 81548c9..207356e 100644
--- a/backend/src/ir/instruction.hxx
+++ b/backend/src/ir/instruction.hxx
@@ -106,3 +106,5 @@  DECL_INSN(IF, BranchInstruction)
 DECL_INSN(ENDIF, BranchInstruction)
 DECL_INSN(ELSE, BranchInstruction)
 DECL_INSN(WHILE, BranchInstruction)
+DECL_INSN(CALC_TIMESTAMP, CalcTimestampInstruction)
+DECL_INSN(STORE_PROFILING, StoreProfilingInstruction)