threadutils.cc

Go to the documentation of this file.

#include "ion/port/threadutils.h"

#include <cstring>  // NOLINT
#include <iostream>  // NOLINT

#if defined(ION_PLATFORM_WINDOWS)
#  define API_DECL WINAPI
#else
#  include <sched.h>
#  include <stdio.h>
#  define API_DECL
#endif

#if defined(ION_PLATFORM_ASMJS) || defined(ION_PLATFORM_NACL)
# define THREAD_NAMING_SUPPORTED 0
#else
# define THREAD_NAMING_SUPPORTED 1
#endif

namespace ion {
namespace port {

namespace {




static ThreadId InitMainThreadId(ThreadId id) {
  static ThreadId main_thread_id = kInvalidThreadId;
  if (id == kInvalidThreadId) {
    if (main_thread_id == kInvalidThreadId)
      main_thread_id = GetCurrentThreadId();
  } else {
    main_thread_id = id;
  }
  return main_thread_id;
}

template <typename ReturnType> static ReturnType CastSuccessCode(bool success) {
  return static_cast<ReturnType>(success ? 0 : 1);
}
template <> void* CastSuccessCode(bool success) {
  return reinterpret_cast<void*>(static_cast<size_t>(success ? 0 : 1));
}

template <typename ReturnType>
static ReturnType API_DECL InvokeThreadFuncPtr(void* arg) {
  ThreadFuncPtr func_ptr = reinterpret_cast<ThreadFuncPtr>(arg);

  const bool success = (*func_ptr)();
  return CastSuccessCode<ReturnType>(success);
}

template <typename ReturnType>
static ReturnType API_DECL InvokeThreadFuncStd(void* arg) {
  ThreadStdFunc* func = reinterpret_cast<ThreadStdFunc*>(arg);

  const bool success = (*func)();
  return CastSuccessCode<ReturnType>(success);
}



#if defined(ION_PLATFORM_WINDOWS)

struct ThreadNameInfo {
  ThreadNameInfo() : type(0x1000), flags(0) {}
  DWORD type;        // Must be 0x1000.
  LPCSTR name;       // Pointer to name.
  DWORD  thread_id;  // Thread ID, or -1 to indicate the calling thread.
  DWORD flags;       // Reserved for future use; must be zero.
};

static void CreateThread(const ThreadFuncPtr func_ptr, void* arg,
                         ThreadId* id) {
  if (!::CreateThread(NULL, 0, InvokeThreadFuncPtr<DWORD>, arg, 0, id))
    std::cerr << "***ION error: Unable to create thread: " << GetLastError()
              << "\n";
}

static void CreateThreadStd(const ThreadStdFunc* func, void* arg,
                            ThreadId* id) {
  if (!::CreateThread(NULL, 0, InvokeThreadFuncStd<DWORD>, arg, 0, id))
    std::cerr << "***ION error: Unable to create thread: " << GetLastError()
              << "\n";
}

#endif



#if !defined(ION_PLATFORM_WINDOWS)

static bool CheckPthreadSuccess(const char* what, int result) {
  if (result) {
#if !defined(ION_COVERAGE)  // COV_NF_START
    std::cerr << "Pthread error: " << what << " returned "
              << result << ": " << strerror(result) << "\n";
    return false;
#endif  // COV_NF_END
  }
  return true;
}

static void CreateThread(const ThreadFuncPtr func_ptr, void* arg,
                         ThreadId* id) {
  CheckPthreadSuccess(
      "Creating thread",
      ::pthread_create(id, NULL, InvokeThreadFuncPtr<void*>, arg));
}

static void CreateThreadStd(const ThreadStdFunc* func, void* arg,
                            ThreadId* id) {
  CheckPthreadSuccess(
      "Creating thread",
      ::pthread_create(id, NULL, InvokeThreadFuncStd<void*>, arg));
}

#endif

}  // anonymous namespace




ThreadId SpawnThread(const ThreadFuncPtr func_ptr) {
  InitMainThreadId(kInvalidThreadId);

  ThreadId id = kInvalidThreadId;
  if (func_ptr) {
    void* arg = const_cast<void*>(reinterpret_cast<const void*>(func_ptr));
    CreateThread(func_ptr, arg, &id);
  }
  return id;
}

ThreadId SpawnThreadStd(const ThreadStdFunc* func) {
  InitMainThreadId(kInvalidThreadId);

  ThreadId id = kInvalidThreadId;
  if (func && *func) {
    void* arg = const_cast<void*>(reinterpret_cast<const void*>(func));
    CreateThreadStd(func, arg, &id);
  }
  return id;
}

bool IsThreadNamingSupported() {
  return THREAD_NAMING_SUPPORTED;
}

bool IsMainThread() {
  return GetCurrentThreadId() == InitMainThreadId(kInvalidThreadId);
}

void SetMainThreadId(ThreadId id) {
  InitMainThreadId(id);
}



#if defined(ION_PLATFORM_WINDOWS)

bool JoinThread(ThreadId id) {
  if (id != kInvalidThreadId) {
    if (const HANDLE handle = ::OpenThread(THREAD_ALL_ACCESS, 0, id)) {
      ::WaitForSingleObject(handle, INFINITE);
      ::CloseHandle(handle);
      return true;
    }
    std::cerr << "***ION error: Could not join thread with ID " << id
              << ": error " << GetLastError() << "\n";
  }
  return false;
}

size_t GetMaxThreadNameLength() {
  return 0;
}

bool SetThreadName(const std::string& name) {
  bool success = false;
  ThreadNameInfo info;
  info.name = name.c_str();
  info.thread_id = GetCurrentThreadId();
  __try {
    static const DWORD kMsVcException = 0x406d1388;
    ::RaiseException(kMsVcException, 0, sizeof(info) / sizeof(DWORD),
                     reinterpret_cast<ULONG_PTR*>(&info));
    success = true;
  } __except(EXCEPTION_CONTINUE_EXECUTION) {
    std::cerr << "***ION error: Unable to name thread with ID "
              << info.thread_id << "\n";
  }
  return success;
}

void YieldThread() {
  ::SwitchToThread();
}

ThreadId GetCurrentThreadId() {
  return ::GetCurrentThreadId();
}

ThreadLocalStorageKey CreateThreadLocalStorageKey() {
  ThreadLocalStorageKey key = ::TlsAlloc();
  if (key == TLS_OUT_OF_INDEXES) {
    std::cerr << "***ION error: Unable to create thread-local storage key: "
              << GetLastError() << "\n";
    key = kInvalidThreadLocalStorageKey;
  }
  return key;
}

bool SetThreadLocalStorage(ThreadLocalStorageKey key, void* ptr) {
  if (key != kInvalidThreadLocalStorageKey) {
    if (::TlsSetValue(key, ptr))
      return true;
    std::cerr << "***ION error: Unable to set thread-local storage pointer: "
              << GetLastError() << "\n";
  }
  return false;
}

void* GetThreadLocalStorage(ThreadLocalStorageKey key) {
  return key == kInvalidThreadLocalStorageKey ? NULL : ::TlsGetValue(key);
}

bool DeleteThreadLocalStorageKey(ThreadLocalStorageKey key) {
  if (key != kInvalidThreadLocalStorageKey) {
    if (::TlsFree(key))
      return true;
    std::cerr << "***ION error: Unable to delete thread-local storage key: "
              << GetLastError() << "\n";
  }
  return false;
}
#endif



#if !defined(ION_PLATFORM_WINDOWS)

bool JoinThread(ThreadId id) {
  if (id != kInvalidThreadId) {
    return CheckPthreadSuccess("Joining thread", ::pthread_join(id, NULL));
  }
  return false;
}

size_t GetMaxThreadNameLength() {
#if THREAD_NAMING_SUPPORTED
  static const size_t kMaxThreadNameLength = 16;
  return kMaxThreadNameLength - 1U;
#else
  return 0;
#endif
}

bool SetThreadName(const std::string& name) {
#if THREAD_NAMING_SUPPORTED
  std::string truncated_name = name;
  if (const size_t max_len = GetMaxThreadNameLength())
    truncated_name = truncated_name.substr(0, max_len);
#  if defined(ION_PLATFORM_IOS) || defined(ION_PLATFORM_MAC)
  return CheckPthreadSuccess(
      "Naming thread", ::pthread_setname_np(truncated_name.c_str()));
#  else
  return CheckPthreadSuccess(
      "Naming thread",
      ::pthread_setname_np(GetCurrentThreadId(), truncated_name.c_str()));
#  endif
#else
  return false;
#endif
}

void YieldThread() {
  CheckPthreadSuccess("Yielding thread", sched_yield());
}

ThreadId GetCurrentThreadId() {
  return ::pthread_self();
}

ThreadLocalStorageKey CreateThreadLocalStorageKey() {
  ThreadLocalStorageKey key = kInvalidThreadLocalStorageKey;
  CheckPthreadSuccess("Creating thread-local storage key",
                      ::pthread_key_create(&key, NULL));
  return key;
}

bool SetThreadLocalStorage(ThreadLocalStorageKey key, void* ptr) {
  if (key != kInvalidThreadLocalStorageKey) {
    return CheckPthreadSuccess("Setting thread-local storage area",
                               ::pthread_setspecific(key, ptr));
  }
  return false;
}

void* GetThreadLocalStorage(ThreadLocalStorageKey key) {
  return key == kInvalidThreadLocalStorageKey ? NULL :
      ::pthread_getspecific(key);
}

bool DeleteThreadLocalStorageKey(ThreadLocalStorageKey key) {
  if (key != kInvalidThreadLocalStorageKey) {
    return CheckPthreadSuccess("Deleting thread-local storage key",
                               ::pthread_key_delete(key));
  }
  return false;
}

#endif

#undef API_DECL
#undef THREAD_NAMING_SUPPORTED

}  // namespace port
}  // namespace ion