rocm-systems/rocclr/runtime/device/gpu/gpucounters.hpp

//
// Copyright (c) 2009 Advanced Micro Devices, Inc. All rights reserved.
//
#ifndef GPUCOUNTERS_HPP_
#define GPUCOUNTERS_HPP_

#include "top.hpp"
#include "device/device.hpp"
#include "device/gpu/gpudevice.hpp"

namespace gpu {

class VirtualGPU;

class CalCounterReference : public amd::ReferenceCountedObject {
 public:
  //! Default constructor
  CalCounterReference(VirtualGPU& gpu,  //!< Virtual GPU device object
                      gslQueryObject gslCounter)
      : gpu_(gpu), counter_(gslCounter), results_(NULL) {}

  //! Get CAL counter
  gslQueryObject gslCounter() const { return counter_; }

  //! Returns the virtual GPU device
  const VirtualGPU& gpu() const { return gpu_; }

  //! Increases the results array for this CAL counter(container)
  bool growResultArray(uint maxIndex  //!< the maximum HW counter index in the CAL counter
                       );

  //! Returns the CAL counter results
  uint64_t* results() const { return results_; }

 protected:
  //! Default destructor
  ~CalCounterReference();

 private:
  //! Disable copy constructor
  CalCounterReference(const CalCounterReference&);

  //! Disable operator=
  CalCounterReference& operator=(const CalCounterReference&);

  VirtualGPU& gpu_;         //!< The virtual GPU device object
  gslQueryObject counter_;  //!< GSL object counter
  uint64_t* results_;       //!< CAL counter results
};

//! Performance counter implementation on GPU
class PerfCounter : public device::PerfCounter {
 public:
  //! The performance counter info
  struct Info : public amd::EmbeddedObject {
    uint blockIndex_;    //!< Index of the block to configure
    uint counterIndex_;  //!< Index of the hardware counter
    uint eventIndex_;    //!< Event you wish to count with the counter
  };

  //! The PerfCounter flags
  enum Flags { BeginIssued = 0x00000001, EndIssued = 0x00000002, ResultReady = 0x00000004 };

  //! Constructor for the GPU PerfCounter object
  PerfCounter(const Device& device,   //!< A GPU device object
              const VirtualGPU& gpu,  //!< Virtual GPU device object
              cl_uint blockIndex,     //!< HW block index
              cl_uint counterIndex,   //!< Counter index within the block
              cl_uint eventIndex)     //!< Event index for profiling
      : gpuDevice_(device),
        gpu_(gpu),
        calRef_(NULL),
        flags_(0),
        counter_(0),
        index_(0) {
    info_.blockIndex_ = blockIndex;
    info_.counterIndex_ = counterIndex;
    info_.eventIndex_ = eventIndex;
  }

  //! Destructor for the GPU PerfCounter object
  virtual ~PerfCounter();

  //! Creates the current object
  bool create(CalCounterReference* calRef  //!< Reference counter
              );

  //! Returns the specific information about the counter
  uint64_t getInfo(uint64_t infoType  //!< The type of returned information
                   ) const;

  //! Returns the GPU device, associated with the current object
  const Device& dev() const { return gpuDevice_; }

  //! Returns the virtual GPU device
  const VirtualGPU& gpu() const { return gpu_; }

  //! Returns the CAL performance counter descriptor
  const Info* info() const { return &info_; }

  //! Returns the Info structure for performance counter
  gslQueryObject gslCounter() const { return counter_; }

 private:
  //! Disable default copy constructor
  PerfCounter(const PerfCounter&);

  //! Disable default operator=
  PerfCounter& operator=(const PerfCounter&);

  const Device& gpuDevice_;  //!< The backend device
  const VirtualGPU& gpu_;    //!< The virtual GPU device object

  CalCounterReference* calRef_;  //!< Reference counter
  uint flags_;                   //!< The perfcounter object state
  Info info_;                    //!< The info structure for perfcounter
  gslQueryObject counter_;       //!< GSL counter object
  uint index_;                   //!< Counter index in the CAL container
};

}  // namespace gpu

#endif  // GPUCOUNTERS_HPP_