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

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

#include "platform/runtime.hpp"
#include "os/os.hpp"
#include "thread/thread.hpp"
#include "device/device.hpp"
#include "utils/flags.hpp"
#include "utils/options.hpp"
#include "platform/context.hpp"
#include "platform/agent.hpp"

#include "amdocl/cl_gl_amd.hpp"

#ifdef _WIN32
#include <d3d10_1.h>
#include <dxgi.h>
#include "CL/cl_d3d10.h"
#endif  //_WIN32

#if defined(_MSC_VER)  // both Win32 and Win64
#include <intrin.h>
#endif

#include <atomic>
#include <cstdlib>
#include <iostream>

namespace amd {

#ifdef __linux__

static void __runtime_exit() __attribute__((destructor(102)));
static void __runtime_exit() {
  if (ENABLE_CAL_SHUTDOWN) {
    Runtime::tearDown();
  }
}

#endif

volatile bool Runtime::initialized_ = false;

bool Runtime::init() {
  if (initialized_) {
    return true;
  }

  // Enter a very basic critical region. We want to prevent 2 threads
  // from concurrently executing the init() routines. We can't use a
  // Monitor since the system is not yet initialized.

  static std::atomic_flag lock = ATOMIC_FLAG_INIT;
  struct CriticalRegion {
    std::atomic_flag& lock_;
    CriticalRegion(std::atomic_flag& lock) : lock_(lock) {
      while (lock.test_and_set(std::memory_order_acquire)) {
        Os::yield();
      }
    }
    ~CriticalRegion() { lock_.clear(std::memory_order_release); }
  } region(lock);

  if (initialized_) {
    return true;
  }

  if (!Flag::init() || !option::init() || !Device::init()
      // Agent initializes last
      || !Agent::init()) {
    return false;
  }

  initialized_ = true;
  return true;
}

void Runtime::tearDown() {
  if (!initialized_) {
    return;
  }

  Agent::tearDown();
  Device::tearDown();
  option::teardown();
  Flag::tearDown();
}

uint ReferenceCountedObject::retain() { return ++make_atomic(referenceCount_); }

uint ReferenceCountedObject::release() {
  uint newCount = --make_atomic(referenceCount_);
  if (newCount == 0) {
    if (terminate()) {
      delete this;
    }
  }
  return newCount;
}

#ifdef _WIN32
#ifdef DEBUG
static int reportHook(int reportType, char* message, int* returnValue) {
  if (returnValue) {
    *returnValue = 1;
  }
  std::cerr << message;
  ::exit(3);
  return TRUE;
}
#endif  // DEBUG

extern "C" BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID reserved) {
  switch (reason) {
    case DLL_PROCESS_ATTACH:
#ifdef DEBUG
      if (!AMD_OCL_ENABLE_MESSAGE_BOX) {
        _CrtSetReportHook(reportHook);
        _set_error_mode(_OUT_TO_STDERR);
      }
#endif  // DEBUG
      break;
    case DLL_PROCESS_DETACH:
      if (!reserved || ENABLE_CAL_SHUTDOWN) {
        Runtime::tearDown();
      }
      break;
    case DLL_THREAD_DETACH: {
      amd::Thread* thread = amd::Thread::current();
      delete thread;
    } break;
    default:
      break;
  }
  return true;
}
#endif

}  // namespace amd