rocm-systems/rocclr/runtime/device/cpu/cpukernel.hpp

//
// Copyright (c) 2011 Advanced Micro Devices, Inc. All rights reserved.
//

#ifndef CPUKERNEL_HPP_
#define CPUKERNEL_HPP_

#include "top.hpp"
#include "device/device.hpp"
#include <amdocl/cl_kernel.h>

#include "device/cpu/cpumapping.hpp"

//! \namespace cpu CPU Device Implementation
namespace cpu {

//! \class CPU kernel
class Kernel : public device::Kernel {
 private:
  const void* entryPoint_;  //!< entry for the kernel

  std::vector<std::pair<size_t, size_t> > args_;
  std::vector<std::pair<HCtoDCmap, size_t> > HCtoDCmaps_;
  std::vector<HCtoDCmap> internal_maps_;

 public:
  uint nature_;       //!< kernel's nature
  uint privateSize_;  //!< WorkItem's private memory size (in bytes)

 private:
  //! Disable default copy constructor
  Kernel(const Kernel&);
  //! Disable operator=
  Kernel& operator=(const Kernel&);

 public:
  void addArg(size_t size, size_t alignment) {
    args_.push_back(std::pair<size_t, size_t>(size, alignment));
  }

  size_t getArgSize(int argIndex) const { return args_[argIndex].first; }

  size_t getArgAlignment(int argIndex) const { return args_[argIndex].second; }

  void addInternalMap(HCtoDCmap* new_map) {
    if (new_map != NULL) {
      internal_maps_.push_back(*new_map);
      this->addInternalMap(new_map->internal_field_map);
      this->addInternalMap(new_map->next_field_map);
    } else
      return;
  }

  void addHCtoDCmap(HCtoDCmap* new_map) {
    if (new_map != NULL) {
      if (HCtoDCmaps_.size() > 0)
        HCtoDCmaps_.push_back(std::pair<HCtoDCmap, size_t>(*new_map, HCtoDCmaps_.back().second));
      else
        HCtoDCmaps_.push_back(std::pair<HCtoDCmap, size_t>(*new_map, 0));
    } else
      return;
  }

  HCtoDCmap getHCtoDCmap(int mapIndex) const { return HCtoDCmaps_[mapIndex].first; }


  uint getArgNumber() { return HCtoDCmaps_.size(); }

  //! Default constructor
  Kernel(const std::string& name)
      : device::Kernel(name), entryPoint_(NULL), nature_(0), privateSize_(CLK_PRIVATE_MEMORY_SIZE) {
    workGroupInfo_.size_ = CPU_MAX_WORKGROUP_SIZE;
  }

  //! Default destructor
  ~Kernel() {}

  //! Returns the CPU kernel entry point
  const void* getEntryPoint() const { return entryPoint_; }

  //! Sets the CPU kernel entry point
  void setEntryPoint(const void* entryPoint) { entryPoint_ = entryPoint; }

  //! Returns true if the kernel has a call to barrier
  bool hasBarrier() const { return 0 != (nature_ & KN_HAS_BARRIER); }

  //! Returns the private memory size of a single WorkItem
  uint getWorkItemPrivateMemSize() const { return privateSize_; }
};

}  // namespace cpu

#endif  // CPUKERNEL_HPP_