pthread_t* thread,

const pthread_attr_t* attribs,

void* (*threadfunc)(void*),

void* thread_arg

) {

static_cast<void>(attribs);

LPTHREAD_START_ROUTINE func = reinterpret_cast<LPTHREAD_START_ROUTINE>(threadfunc);

*thread = CreateThread(nullptr, 0, func, thread_arg, 0, nullptr);

// Ensure we return 0 on success, non-zero on error

if (*thread == NULL)

{

return 1;

}

return 0;

pthread_t thread,

int thread_index

) {

// Skip thread assignment for hardware with a single CPU group

int group_count = GetActiveProcessorGroupCount();

if (group_count == 1)

{

return;

}

// Ensure we have a valid assign if user creates more threads than cores

int assign_index = thread_index % get_cpu_count();

int assign_group { 0 };

int assign_group_cpu_count { 0 };

// Determine which core group and core in the group to use for this thread

int group_cpu_count_sum { 0 };

for (int group = 0; group < group_count; group++)

{

int group_cpu_count = static_cast<int>(GetMaximumProcessorCount(group));

group_cpu_count_sum += group_cpu_count;

if (assign_index < group_cpu_count_sum)

{

assign_group = group;

assign_group_cpu_count = group_cpu_count;

break;

}

}

// Set the affinity to the assigned group, and all supported cores

GROUP_AFFINITY affinity {};

affinity.Mask = (1 << assign_group_cpu_count) - 1;

affinity.Group = assign_group;

SetThreadGroupAffinity(thread, &affinity, nullptr);

pthread_t thread,

void** value

) {

static_cast<void>(value);

WaitForSingleObject(thread, INFINITE);

return 0;

{

DWORD cpu_count = GetActiveProcessorCount(ALL_PROCESSOR_GROUPS);

return static_cast<int>(cpu_count);

{

FILETIME tv;

GetSystemTimePreciseAsFileTime(&tv);

unsigned long long ticks = tv.dwHighDateTime;

ticks = (ticks << 32) | tv.dwLowDateTime;

return static_cast<double>(ticks) / 1.0e7;

const char* name

) {

// Names are limited to 16 characters

wchar_t wname [16] { 0 };

size_t name_len = std::strlen(name);

size_t clamp_len = std::min<size_t>(name_len, 15);

// We know we only have basic 7-bit ASCII so just widen

for (size_t i = 0; i < clamp_len; i++)

{

wname[i] = static_cast<wchar_t>(name[i]);

}

SetThreadDescription(GetCurrentThread(), wname);

{

timeval tv;

gettimeofday(&tv, 0);

return static_cast<double>(tv.tv_sec) + static_cast<double>(tv.tv_usec) * 1.0e-6;

const char* name

) {

// No standard mechanism, so be defensive here

#if defined(__linux__)

pthread_setname_np(pthread_self(), name);

#elif defined(__APPLE__)

pthread_setname_np(name);

#else

(void)name;

#endif

{

/** @brief The native thread handle. */

pthread_t thread_handle;

/** @brief The total number of threads in the thread pool. */

int thread_count;

/** @brief The thread index in the thread pool. */

int thread_id;

/** @brief The user thread function to execute. */

void (*func)(int, int, void*);

/** @brief The user thread payload. */

void* payload;

const char* operation,

int thread_count,

void (*func)(int, int, void*),

void *payload

) {

// Directly execute single threaded workloads on this thread

if (thread_count <= 1)

{

func(1, 0, payload);

return;

}

// Otherwise spawn worker threads

std::vector<launch_desc> thread_descs(thread_count);

int actual_thread_count { 0 };

for (int i = 0; i < thread_count; i++)

{

thread_descs[actual_thread_count].thread_count = thread_count;

thread_descs[actual_thread_count].thread_id = actual_thread_count;

thread_descs[actual_thread_count].payload = payload;

thread_descs[actual_thread_count].func = func;

// Handle pthread_create failing by simply using fewer threads

int error = pthread_create(

&(thread_descs[actual_thread_count].thread_handle),

nullptr,

launch_threads_helper,

reinterpret_cast<void*>(&thread_descs[actual_thread_count]));

// Track how many threads we actually created

if (!error)

{

// Windows needs explicit thread assignment to handle large core count systems

#if defined(_WIN32) && !defined(__CYGWIN__)

set_group_affinity(

thread_descs[actual_thread_count].thread_handle,

actual_thread_count);

#endif

actual_thread_count++;

}

}

// If we did not create thread_count threads then emit a warning

if (actual_thread_count != thread_count)

{

int log_count = actual_thread_count == 0 ? 1 : actual_thread_count;

const char* log_s = log_count == 1 ? "" : "s";

printf("WARNING: %s using %d thread%s due to thread creation error\n\n",

operation, log_count, log_s);

}

// If we managed to spawn any threads wait for them to complete

if (actual_thread_count != 0)

{

for (int i = 0; i < actual_thread_count; i++)

{

pthread_join(thread_descs[i].thread_handle, nullptr);

}

}

// Else fall back to using this thread

else

{

func(1, 0, payload);

}