rocm-systems/rocclr/runtime/platform/agent.cpp

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

#include "platform/agent.hpp"
#include "platform/object.hpp"
#include "os/os.hpp"
#include "amdocl/cl_common.hpp"

#include <cstdlib>
#include <cstring>
#include <string>
#include <sstream>

namespace amd {


typedef cl_int(CL_CALLBACK* clAgent_OnLoad_fn)(cl_agent* agent);
typedef void(CL_CALLBACK* clAgent_OnUnload_fn)(cl_agent* agent);

Agent::Agent(const char* moduleName) : ready_(false) {
  ::memset(&callbacks_, '\0', sizeof(callbacks_));
  ::memset(&capabilities_, '\0', sizeof(capabilities_));

  library_ = Os::loadLibrary(moduleName);
  if (library_ == NULL) {
    return;
  }

  clAgent_OnLoad_fn onLoad =
      reinterpret_cast<clAgent_OnLoad_fn>(Os::getSymbol(library_, "clAgent_OnLoad"));
  if (onLoad == NULL) {
    return;
  }

  _cl_agent* agent = static_cast<_cl_agent*>(this);
  ::memcpy(agent, &entryPoints_, sizeof(entryPoints_));

  // Register in the agents linked-list.
  next_ = list_;
  list_ = this;

  if (onLoad(agent) != CL_SUCCESS) {
    list_ = list_->next_;
  }

  // Mark this instance as ready for use.
  ready_ = true;
}

Agent::~Agent() {
  if (library_ != NULL) {
    clAgent_OnUnload_fn onUnload =
        reinterpret_cast<clAgent_OnUnload_fn>(Os::getSymbol(library_, "clAgent_OnUnload"));

    if (onUnload != NULL) {
      onUnload(static_cast<cl_agent*>(this));
    }

    Os::unloadLibrary(library_);
  }
}

cl_int Agent::setCallbacks(const cl_agent_callbacks* callbacks, size_t size) {
  // FIXME_lmoriche: check size
  memcpy(&callbacks_, callbacks, size);
  return CL_SUCCESS;
}

cl_int Agent::getCapabilities(cl_agent_capabilities* caps) {
  if (caps == NULL) {
    return CL_INVALID_VALUE;
  }
  *caps = capabilities_;
  return CL_SUCCESS;
}

static inline cl_agent_capabilities operator~(const cl_agent_capabilities& src) {
  cl_agent_capabilities result;

  const char* a = reinterpret_cast<const char*>(&src);
  char* b = reinterpret_cast<char*>(&result);
  for (size_t i = 0; i < sizeof(cl_agent_capabilities); ++i) {
    *b++ = ~*a++;
  }

  return result;
}

static inline cl_agent_capabilities operator|(const cl_agent_capabilities& lhs,
                                              const cl_agent_capabilities& rhs) {
  cl_agent_capabilities result;

  const char* a = reinterpret_cast<const char*>(&lhs);
  const char* b = reinterpret_cast<const char*>(&rhs);
  char* c = reinterpret_cast<char*>(&result);
  for (size_t i = 0; i < sizeof(cl_agent_capabilities); ++i) {
    *c++ = *a++ | *b++;
  }

  return result;
}

static inline cl_agent_capabilities operator&(const cl_agent_capabilities& lhs,
                                              const cl_agent_capabilities& rhs) {
  cl_agent_capabilities result;

  const char* a = reinterpret_cast<const char*>(&lhs);
  const char* b = reinterpret_cast<const char*>(&rhs);
  char* c = reinterpret_cast<char*>(&result);
  for (size_t i = 0; i < sizeof(cl_agent_capabilities); ++i) {
    *c++ = *a++ & *b++;
  }

  return result;
}

static inline bool operator==(const cl_agent_capabilities& lhs, const cl_agent_capabilities& rhs) {
  const char* a = reinterpret_cast<const char*>(&lhs);
  const char* b = reinterpret_cast<const char*>(&rhs);
  for (size_t i = 0; i < sizeof(cl_agent_capabilities); ++i) {
    if (*a++ != *b++) {
      return false;
    }
  }

  return true;
}

static inline bool operator!=(const cl_agent_capabilities& lhs, const cl_agent_capabilities& rhs) {
  return !(lhs == rhs);
}

cl_int Agent::setCapabilities(const cl_agent_capabilities* caps, bool install) {
  ScopedLock sl(capabilitiesLock_);

  if (caps == NULL || *caps != (*caps & potentialCapabilities_)) {
    return CL_INVALID_VALUE;
  }

  if (install) {
    capabilities_ = capabilities_ | *caps;
  } else {
    capabilities_ = capabilities_ & ~*caps;
  }

  memset(&enabledCapabilities_, '\0', sizeof(enabledCapabilities_));
  for (Agent* agent = list_; agent != NULL; agent = agent->next_) {
    enabledCapabilities_ = enabledCapabilities_ | agent->capabilities_;
  }

  return CL_SUCCESS;
}

bool Agent::init() {
  ::memset(&potentialCapabilities_, '\0', sizeof(potentialCapabilities_));
  potentialCapabilities_.canGenerateContextEvents = 1;
  potentialCapabilities_.canGenerateCommandQueueEvents = 1;
  potentialCapabilities_.canGenerateEventEvents = 1;
  //    potentialCapabilities_.canGenerateMemObjectEvents    = 1;
  //    potentialCapabilities_.canGenerateSamplerEvents      = 1;
  //    potentialCapabilities_.canGenerateProgramEvents      = 1;
  //    potentialCapabilities_.canGenerateKernelEvents       = 1;

  const char* envVar = ::getenv("CL_AGENT");
  if (envVar == NULL) {
    return true;
  }

  std::string token, modules = envVar;
  std::istringstream iss(modules);

  while (getline(iss, token, ',')) {
    Agent* agent = new Agent(token.c_str());
    if (agent == NULL || !agent->isReady()) {
      delete agent;

      // Only return an error if we failed the Agent allocation. Other
      // error (the agent is not ready) can be ignored.
      return agent != NULL;
    }
  }

  return true;
}

void Agent::tearDown() {
  while (list_ != NULL) {
    Agent* agent = list_;
    list_ = list_->next_;
    delete agent;
  }
}

namespace agent {

static cl_int CL_API_CALL GetVersionNumber(cl_agent* agent, cl_int* version_ret) {
  if (version_ret == NULL) {
    return CL_INVALID_VALUE;
  }
  *version_ret = CL_AGENT_VERSION_1_0;
  return CL_SUCCESS;
}

static cl_int CL_API_CALL GetPlatform(cl_agent* agent, cl_platform_id* platform_id_ret) {
  if (platform_id_ret == NULL) {
    return CL_INVALID_VALUE;
  }
  *platform_id_ret = AMD_PLATFORM;
  return CL_SUCCESS;
}

static cl_int CL_API_CALL GetTime(cl_agent* agent, cl_long* time_nanos) {
  if (time_nanos == NULL) {
    return CL_INVALID_VALUE;
  }
  *time_nanos = Os::timeNanos() + Os::offsetToEpochNanos();
  return CL_SUCCESS;
}

static cl_int CL_API_CALL SetCallbacks(cl_agent* agent, const cl_agent_callbacks* callbacks,
                                       size_t size) {
  return Agent::get(agent)->setCallbacks(callbacks, size);
}

static cl_int CL_API_CALL GetPotentialCapabilities(cl_agent* agent,
                                                   cl_agent_capabilities* capabilities) {
  if (capabilities == NULL) {
    return CL_INVALID_VALUE;
  }

  *capabilities = Agent::potentialCapabilities();
  return CL_SUCCESS;
}

static cl_int CL_API_CALL GetCapabilities(cl_agent* agent, cl_agent_capabilities* capabilities) {
  return Agent::get(agent)->getCapabilities(capabilities);
}

static cl_int CL_API_CALL SetCapabilities(cl_agent* agent,
                                          const cl_agent_capabilities* capabilities,
                                          cl_agent_capability_action action) {
  return Agent::get(agent)->setCapabilities(capabilities, action == CL_AGENT_ADD_CAPABILITIES);
}

static cl_int CL_API_CALL GetICDDispatchTable(cl_agent* agent, cl_icd_dispatch_table* table,
                                              size_t size) {
  // FIXME_lmoriche: check size
  memcpy(table, amd::ICDDispatchedObject::icdVendorDispatch_, size);
  return CL_SUCCESS;
}

static cl_int CL_API_CALL SetICDDispatchTable(cl_agent* agent, const cl_icd_dispatch_table* table,
                                              size_t size) {
  // FIXME_lmoriche: check size
  memcpy(amd::ICDDispatchedObject::icdVendorDispatch_, table, size);
  return CL_SUCCESS;
}

}  // namespace agent

cl_agent Agent::entryPoints_ = {agent::GetVersionNumber,
                                agent::GetPlatform,
                                agent::GetTime,
                                agent::SetCallbacks,
                                agent::GetPotentialCapabilities,
                                agent::GetCapabilities,
                                agent::SetCapabilities,
                                agent::GetICDDispatchTable,
                                agent::SetICDDispatchTable};

void Agent::postContextCreate(cl_context context) {
  for (Agent* agent = list_; agent != NULL; agent = agent->next_) {
    acContextCreate_fn callback = agent->callbacks_.ContextCreate;
    if (callback != NULL && agent->canGenerateContextEvents()) {
      callback(agent, context);
    }
  }
}

void Agent::postContextFree(cl_context context) {
  for (Agent* agent = list_; agent != NULL; agent = agent->next_) {
    acContextFree_fn callback = agent->callbacks_.ContextFree;
    if (callback != NULL && agent->canGenerateContextEvents()) {
      callback(agent, context);
    }
  }
}

void Agent::postCommandQueueCreate(cl_command_queue queue) {
  for (Agent* agent = list_; agent != NULL; agent = agent->next_) {
    acCommandQueueCreate_fn callback = agent->callbacks_.CommandQueueCreate;
    if (callback != NULL && agent->canGenerateCommandQueueEvents()) {
      callback(agent, queue);
    }
  }
}

void Agent::postCommandQueueFree(cl_command_queue queue) {
  for (Agent* agent = list_; agent != NULL; agent = agent->next_) {
    acCommandQueueFree_fn callback = agent->callbacks_.CommandQueueFree;
    if (callback != NULL && agent->canGenerateCommandQueueEvents()) {
      callback(agent, queue);
    }
  }
}

void Agent::postEventCreate(cl_event event, cl_command_type type) {
  for (Agent* agent = list_; agent != NULL; agent = agent->next_) {
    acEventCreate_fn callback = agent->callbacks_.EventCreate;
    if (callback != NULL && agent->canGenerateEventEvents()) {
      callback(agent, event, type);
    }
  }
}

void Agent::postEventFree(cl_event event) {
  for (Agent* agent = list_; agent != NULL; agent = agent->next_) {
    acEventFree_fn callback = agent->callbacks_.EventFree;
    if (callback != NULL && agent->canGenerateEventEvents()) {
      callback(agent, event);
    }
  }
}

void Agent::postEventStatusChanged(cl_event event, cl_int status, cl_long ts) {
  for (Agent* agent = list_; agent != NULL; agent = agent->next_) {
    acEventStatusChanged_fn callback = agent->callbacks_.EventStatusChanged;
    if (callback != NULL && agent->canGenerateEventEvents()) {
      callback(agent, event, status, ts);
    }
  }
}

void Agent::postMemObjectCreate(cl_mem memobj) {
  for (Agent* agent = list_; agent != NULL; agent = agent->next_) {
    acMemObjectCreate_fn callback = agent->callbacks_.MemObjectCreate;
    if (callback != NULL && agent->canGenerateMemObjectEvents()) {
      callback(agent, memobj);
    }
  }
}

void Agent::postMemObjectFree(cl_mem memobj) {
  for (Agent* agent = list_; agent != NULL; agent = agent->next_) {
    acMemObjectFree_fn callback = agent->callbacks_.MemObjectFree;
    if (callback != NULL && agent->canGenerateMemObjectEvents()) {
      callback(agent, memobj);
    }
  }
}

void Agent::postMemObjectAcquired(cl_mem memobj, cl_device_id device, cl_long elapsed) {
  for (Agent* agent = list_; agent != NULL; agent = agent->next_) {
    acMemObjectAcquired_fn callback = agent->callbacks_.MemObjectAcquired;
    if (callback != NULL && agent->canGenerateMemObjectEvents()) {
      callback(agent, memobj, device, elapsed);
    }
  }
}

void Agent::postSamplerCreate(cl_sampler sampler) {
  for (Agent* agent = list_; agent != NULL; agent = agent->next_) {
    acSamplerCreate_fn callback = agent->callbacks_.SamplerCreate;
    if (callback != NULL && agent->canGenerateSamplerEvents()) {
      callback(agent, sampler);
    }
  }
}

void Agent::postSamplerFree(cl_sampler sampler) {
  for (Agent* agent = list_; agent != NULL; agent = agent->next_) {
    acSamplerFree_fn callback = agent->callbacks_.SamplerFree;
    if (callback != NULL && agent->canGenerateSamplerEvents()) {
      callback(agent, sampler);
    }
  }
}

void Agent::postProgramCreate(cl_program program) {
  for (Agent* agent = list_; agent != NULL; agent = agent->next_) {
    acProgramCreate_fn callback = agent->callbacks_.ProgramCreate;
    if (callback != NULL && agent->canGenerateProgramEvents()) {
      callback(agent, program);
    }
  }
}

void Agent::postProgramFree(cl_program program) {
  for (Agent* agent = list_; agent != NULL; agent = agent->next_) {
    acProgramFree_fn callback = agent->callbacks_.ProgramFree;
    if (callback != NULL && agent->canGenerateProgramEvents()) {
      callback(agent, program);
    }
  }
}

void Agent::postProgramBuild(cl_program program) {
  for (Agent* agent = list_; agent != NULL; agent = agent->next_) {
    acProgramBuild_fn callback = agent->callbacks_.ProgramBuild;
    if (callback != NULL && agent->canGenerateProgramEvents()) {
      callback(agent, program);
    }
  }
}

void Agent::postKernelCreate(cl_kernel kernel) {
  for (Agent* agent = list_; agent != NULL; agent = agent->next_) {
    acKernelCreate_fn callback = agent->callbacks_.KernelCreate;
    if (callback != NULL && agent->canGenerateKernelEvents()) {
      callback(agent, kernel);
    }
  }
}

void Agent::postKernelFree(cl_kernel kernel) {
  for (Agent* agent = list_; agent != NULL; agent = agent->next_) {
    acKernelFree_fn callback = agent->callbacks_.KernelFree;
    if (callback != NULL && agent->canGenerateKernelEvents()) {
      callback(agent, kernel);
    }
  }
}

void Agent::postKernelSetArg(cl_kernel kernel, cl_int index, size_t size, const void* value_ptr) {
  for (Agent* agent = list_; agent != NULL; agent = agent->next_) {
    acKernelSetArg_fn callback = agent->callbacks_.KernelSetArg;
    if (callback != NULL && agent->canGenerateKernelEvents()) {
      callback(agent, kernel, index, size, value_ptr);
    }
  }
}

Agent* Agent::list_ = NULL;
Monitor Agent::capabilitiesLock_;
cl_agent_capabilities Agent::enabledCapabilities_ = {0};
cl_agent_capabilities Agent::potentialCapabilities_ = {0};

}  // namespace amd