initial commit

[ROCm/clr commit: 3694ab2ce8]

projects/clr/rocclr/runtime/device/gpu/gputimestamp.hpp

@@ -0,0 +1,132 @@
+//
+// Copyright (c) 2008 Advanced Micro Devices, Inc. All rights reserved.
+//
+#ifndef GPUTIMESTAMP_HPP_
+#define GPUTIMESTAMP_HPP_
+
+#include "device/gpu/gpudefs.hpp"
+#include "device/gpu/gpuresource.hpp"
+
+/*! \addtogroup GPU GPU Resource Implementation
+ *  @{
+ */
+
+//! GPU Device Implementation
+namespace gpu {
+
+class Device;
+class VirtualGPU;
+class Memory;
+
+class TimeStamp : public amd::HeapObject
+{
+public:
+    //! Enums for the timestamp information
+    //! \note *4 is the limitaiton of SDMA HW
+    //! (address has to be aligned by 256 bit)
+    enum TimeStampValue {
+        CommandStartTime        = 0,
+        CommandEndTime          = 4,
+        CommandTotal            = 8
+    };
+
+    //! The TimeStamp object flags
+    union Flags
+    {
+        struct
+        {
+            uint32_t    beginIssued_ : 1;
+            uint32_t    endIssued_   : 1;
+            uint32_t    sdma_        : 1;
+        };
+        uint32_t    value_;
+        Flags(): value_(0)  {}
+    };
+
+    //! Default constructor
+    TimeStamp(
+        const VirtualGPU&   gpu,        //!< Virtual GPU
+        gslMemObject        gslMem,     //!< Buffer with the timer values
+        uint                memOffset,  //!< Offset in the buffer for the current TS
+        address             cpuAddr     //!< CPU pointer for the values in memory
+        );
+
+    //! Default destructor
+    ~TimeStamp();
+
+    //! Starts the timestamp
+    void begin(bool sdma = false);
+
+    //! Ends the timestamp
+    void end(bool sdma = false);
+
+    //! Returns the timestamp result in nano seconds
+    void value(uint64_t* startTime, uint64_t* endTime);
+
+    //! Clear all TimeStamp states
+    void clearStates()
+        { flags_.value_ = 0;
+          values_[CommandStartTime] = 0;
+          values_[CommandEndTime] = 0;
+        }
+
+    //! Timer commands were submitted to HW
+    bool isValid() const { return (flags_.endIssued_) ? true : false; }
+
+private:
+    //! Disable copy constructor
+    TimeStamp(const TimeStamp&);
+
+    //! Disable operator=
+    TimeStamp& operator=(const TimeStamp&);
+
+    //! Returns the GPU device object
+    const VirtualGPU& gpu() const { return gpu_; }
+
+    const VirtualGPU&   gpu_;   //!< Virtual GPU
+    Flags       flags_;         //!< The time stamp state
+    gslMemObject gslMem_;       //!< Buffer with the timer values
+    uint        memOffset_;     //!< Offset in the buffer for the current timer
+    volatile uint64_t* values_; //!< CPU pointer to the timer values
+};
+
+class TimeStampCache : public amd::HeapObject
+{
+public:
+    //! Default constructor
+    TimeStampCache(
+        VirtualGPU& gpu     //!< Virtual GPU object
+        )
+        : gpu_(gpu)
+        , tsBufCpu_(NULL)
+        , tsOffset_(0) {}
+
+    //! Default destructor
+    ~TimeStampCache();
+
+    //! Gets a time stamp object. It will find a freed object or allocate a new one
+    TimeStamp* allocTimeStamp();
+
+    //! Frees a time stamp object
+    void freeTimeStamp(TimeStamp* ts) { freedTS_.push_back(ts); }
+
+private:
+    static const uint   TimerSlotSize = TimeStamp::CommandTotal * sizeof(uint64_t);
+    static const uint   TimerBufSize  = TimerSlotSize * 4096;
+
+    //! Disable copy constructor
+    TimeStampCache(const TimeStampCache&);
+
+    //! Disable operator=
+    TimeStampCache& operator=(const TimeStampCache&);
+
+    std::vector<TimeStamp*> freedTS_;   //!< Array of freed time stamp objects
+    VirtualGPU&       gpu_;             //!< Virtual GPU
+    std::vector<Memory*>    tsBuf_;     //!< Array of memory objects with the timer value
+    address     tsBufCpu_;              //!< CPU pointer for current TS memory
+    uint        tsOffset_;              //!< Active offset in the current mem object
+};
+
+/*@}*/} // namespace gpu
+
+#endif /*GPUTIMESTAMP_HPP_*/