mirror of
https://github.com/bkaradzic/bx.git
synced 2026-02-19 21:43:00 +01:00
Cleanup.
This commit is contained in:
Branimir Karadžić
221
src/sem.cpp
Normal file
221
src/sem.cpp
Normal file
@@ -0,0 +1,221 @@
|
||||
/*
|
||||
* Copyright 2010-2017 Branimir Karadzic. All rights reserved.
|
||||
* License: https://github.com/bkaradzic/bx#license-bsd-2-clause
|
||||
*/
|
||||
|
||||
#include <bx/sem.h>
|
||||
|
||||
#if BX_CONFIG_SUPPORTS_THREADING
|
||||
|
||||
#if BX_PLATFORM_POSIX
|
||||
# include <errno.h>
|
||||
# include <semaphore.h>
|
||||
# include <time.h>
|
||||
# include <pthread.h>
|
||||
#elif BX_PLATFORM_XBOXONE
|
||||
# include <synchapi.h>
|
||||
#elif BX_PLATFORM_XBOX360 || BX_PLATFORM_WINDOWS || BX_PLATFORM_WINRT
|
||||
# include <windows.h>
|
||||
# include <limits.h>
|
||||
#endif // BX_PLATFORM_
|
||||
|
||||
namespace bx
|
||||
{
|
||||
#if BX_PLATFORM_POSIX
|
||||
|
||||
# if BX_CONFIG_SEMAPHORE_PTHREAD
|
||||
Semaphore::Semaphore()
|
||||
: m_count(0)
|
||||
{
|
||||
int result;
|
||||
result = pthread_mutex_init(&m_mutex, NULL);
|
||||
BX_CHECK(0 == result, "pthread_mutex_init %d", result);
|
||||
|
||||
result = pthread_cond_init(&m_cond, NULL);
|
||||
BX_CHECK(0 == result, "pthread_cond_init %d", result);
|
||||
|
||||
BX_UNUSED(result);
|
||||
}
|
||||
|
||||
Semaphore::~Semaphore()
|
||||
{
|
||||
int result;
|
||||
result = pthread_cond_destroy(&m_cond);
|
||||
BX_CHECK(0 == result, "pthread_cond_destroy %d", result);
|
||||
|
||||
result = pthread_mutex_destroy(&m_mutex);
|
||||
BX_CHECK(0 == result, "pthread_mutex_destroy %d", result);
|
||||
|
||||
BX_UNUSED(result);
|
||||
}
|
||||
|
||||
void Semaphore::post(uint32_t _count)
|
||||
{
|
||||
int result = pthread_mutex_lock(&m_mutex);
|
||||
BX_CHECK(0 == result, "pthread_mutex_lock %d", result);
|
||||
|
||||
for (uint32_t ii = 0; ii < _count; ++ii)
|
||||
{
|
||||
result = pthread_cond_signal(&m_cond);
|
||||
BX_CHECK(0 == result, "pthread_cond_signal %d", result);
|
||||
}
|
||||
|
||||
m_count += _count;
|
||||
|
||||
result = pthread_mutex_unlock(&m_mutex);
|
||||
BX_CHECK(0 == result, "pthread_mutex_unlock %d", result);
|
||||
|
||||
BX_UNUSED(result);
|
||||
}
|
||||
|
||||
bool Semaphore::wait(int32_t _msecs)
|
||||
{
|
||||
int result = pthread_mutex_lock(&m_mutex);
|
||||
BX_CHECK(0 == result, "pthread_mutex_lock %d", result);
|
||||
|
||||
# if BX_PLATFORM_NACL || BX_PLATFORM_OSX
|
||||
BX_UNUSED(_msecs);
|
||||
BX_CHECK(-1 == _msecs, "NaCl and OSX don't support pthread_cond_timedwait at this moment.");
|
||||
while (0 == result
|
||||
&& 0 >= m_count)
|
||||
{
|
||||
result = pthread_cond_wait(&m_cond, &m_mutex);
|
||||
}
|
||||
# elif BX_PLATFORM_IOS
|
||||
if (-1 == _msecs)
|
||||
{
|
||||
while (0 == result
|
||||
&& 0 >= m_count)
|
||||
{
|
||||
result = pthread_cond_wait(&m_cond, &m_mutex);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
timespec ts;
|
||||
ts.tv_sec = _msecs/1000;
|
||||
ts.tv_nsec = (_msecs%1000)*1000;
|
||||
|
||||
while (0 == result
|
||||
&& 0 >= m_count)
|
||||
{
|
||||
result = pthread_cond_timedwait_relative_np(&m_cond, &m_mutex, &ts);
|
||||
}
|
||||
}
|
||||
# else
|
||||
timespec ts;
|
||||
clock_gettime(CLOCK_REALTIME, &ts);
|
||||
ts.tv_sec += _msecs/1000;
|
||||
ts.tv_nsec += (_msecs%1000)*1000;
|
||||
|
||||
while (0 == result
|
||||
&& 0 >= m_count)
|
||||
{
|
||||
result = pthread_cond_timedwait(&m_cond, &m_mutex, &ts);
|
||||
}
|
||||
# endif // BX_PLATFORM_NACL || BX_PLATFORM_OSX
|
||||
bool ok = 0 == result;
|
||||
|
||||
if (ok)
|
||||
{
|
||||
--m_count;
|
||||
}
|
||||
|
||||
result = pthread_mutex_unlock(&m_mutex);
|
||||
BX_CHECK(0 == result, "pthread_mutex_unlock %d", result);
|
||||
|
||||
BX_UNUSED(result);
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
# else
|
||||
|
||||
Semaphore::Semaphore()
|
||||
{
|
||||
int32_t result = sem_init(&m_handle, 0, 0);
|
||||
BX_CHECK(0 == result, "sem_init failed. errno %d", errno);
|
||||
BX_UNUSED(result);
|
||||
}
|
||||
|
||||
Semaphore::~Semaphore()
|
||||
{
|
||||
int32_t result = sem_destroy(&m_handle);
|
||||
BX_CHECK(0 == result, "sem_destroy failed. errno %d", errno);
|
||||
BX_UNUSED(result);
|
||||
}
|
||||
|
||||
void Semaphore::post(uint32_t _count)
|
||||
{
|
||||
int32_t result;
|
||||
for (uint32_t ii = 0; ii < _count; ++ii)
|
||||
{
|
||||
result = sem_post(&m_handle);
|
||||
BX_CHECK(0 == result, "sem_post failed. errno %d", errno);
|
||||
}
|
||||
BX_UNUSED(result);
|
||||
}
|
||||
|
||||
bool Semaphore::wait(int32_t _msecs)
|
||||
{
|
||||
# if BX_PLATFORM_NACL || BX_PLATFORM_OSX
|
||||
BX_CHECK(-1 == _msecs, "NaCl and OSX don't support sem_timedwait at this moment."); BX_UNUSED(_msecs);
|
||||
return 0 == sem_wait(&m_handle);
|
||||
# else
|
||||
if (0 > _msecs)
|
||||
{
|
||||
int32_t result;
|
||||
do
|
||||
{
|
||||
result = sem_wait(&m_handle);
|
||||
} // keep waiting when interrupted by a signal handler...
|
||||
while (-1 == result && EINTR == errno);
|
||||
BX_CHECK(0 == result, "sem_wait failed. errno %d", errno);
|
||||
return 0 == result;
|
||||
}
|
||||
|
||||
timespec ts;
|
||||
clock_gettime(CLOCK_REALTIME, &ts);
|
||||
ts.tv_sec += _msecs/1000;
|
||||
ts.tv_nsec += (_msecs%1000)*1000;
|
||||
return 0 == sem_timedwait(&m_handle, &ts);
|
||||
# endif // BX_PLATFORM_
|
||||
}
|
||||
# endif // BX_CONFIG_SEMAPHORE_PTHREAD
|
||||
|
||||
#elif BX_PLATFORM_XBOX360 || BX_PLATFORM_XBOXONE || BX_PLATFORM_WINDOWS || BX_PLATFORM_WINRT
|
||||
|
||||
Semaphore::Semaphore()
|
||||
{
|
||||
#if BX_PLATFORM_XBOXONE || BX_PLATFORM_WINRT
|
||||
m_handle = CreateSemaphoreExW(NULL, 0, LONG_MAX, NULL, 0, SEMAPHORE_ALL_ACCESS);
|
||||
#else
|
||||
m_handle = CreateSemaphoreA(NULL, 0, LONG_MAX, NULL);
|
||||
#endif
|
||||
BX_CHECK(NULL != m_handle, "Failed to create Semaphore!");
|
||||
}
|
||||
|
||||
Semaphore::~Semaphore()
|
||||
{
|
||||
CloseHandle(m_handle);
|
||||
}
|
||||
|
||||
void Semaphore::post(uint32_t _count)
|
||||
{
|
||||
ReleaseSemaphore(m_handle, _count, NULL);
|
||||
}
|
||||
|
||||
bool Semaphore::wait(int32_t _msecs)
|
||||
{
|
||||
DWORD milliseconds = (0 > _msecs) ? INFINITE : _msecs;
|
||||
#if BX_PLATFORM_XBOXONE || BX_PLATFORM_WINRT
|
||||
return WAIT_OBJECT_0 == WaitForSingleObjectEx(m_handle, milliseconds, FALSE);
|
||||
#else
|
||||
return WAIT_OBJECT_0 == WaitForSingleObject(m_handle, milliseconds);
|
||||
#endif
|
||||
}
|
||||
#endif // BX_PLATFORM_
|
||||
|
||||
} // namespace bx
|
||||
|
||||
#endif // BX_CONFIG_SUPPORTS_THREADING
|
||||
208
src/thread.cpp
Normal file
208
src/thread.cpp
Normal file
@@ -0,0 +1,208 @@
|
||||
/*
|
||||
* Copyright 2010-2017 Branimir Karadzic. All rights reserved.
|
||||
* License: https://github.com/bkaradzic/bx#license-bsd-2-clause
|
||||
*/
|
||||
|
||||
#include <bx/thread.h>
|
||||
|
||||
#if BX_CONFIG_SUPPORTS_THREADING
|
||||
|
||||
namespace bx
|
||||
{
|
||||
Thread::Thread()
|
||||
#if BX_PLATFORM_WINDOWS || BX_PLATFORM_XBOX360 || BX_PLATFORM_XBOXONE || BX_PLATFORM_WINRT
|
||||
: m_handle(INVALID_HANDLE_VALUE)
|
||||
, m_threadId(UINT32_MAX)
|
||||
#elif BX_PLATFORM_POSIX
|
||||
: m_handle(0)
|
||||
#endif // BX_PLATFORM_
|
||||
, m_fn(NULL)
|
||||
, m_userData(NULL)
|
||||
, m_stackSize(0)
|
||||
, m_exitCode(0 /*EXIT_SUCCESS*/)
|
||||
, m_running(false)
|
||||
{
|
||||
}
|
||||
|
||||
Thread::~Thread()
|
||||
{
|
||||
if (m_running)
|
||||
{
|
||||
shutdown();
|
||||
}
|
||||
}
|
||||
|
||||
void Thread::init(ThreadFn _fn, void* _userData, uint32_t _stackSize, const char* _name)
|
||||
{
|
||||
BX_CHECK(!m_running, "Already running!");
|
||||
|
||||
m_fn = _fn;
|
||||
m_userData = _userData;
|
||||
m_stackSize = _stackSize;
|
||||
m_running = true;
|
||||
|
||||
#if BX_PLATFORM_WINDOWS || BX_PLATFORM_XBOX360 || BX_PLATFORM_XBOXONE
|
||||
m_handle = ::CreateThread(NULL
|
||||
, m_stackSize
|
||||
, (LPTHREAD_START_ROUTINE)threadFunc
|
||||
, this
|
||||
, 0
|
||||
, NULL
|
||||
);
|
||||
#elif BX_PLATFORM_WINRT
|
||||
m_handle = CreateEventEx(nullptr, nullptr, CREATE_EVENT_MANUAL_RESET, EVENT_ALL_ACCESS);
|
||||
auto workItemHandler = ref new WorkItemHandler([=](IAsyncAction^)
|
||||
{
|
||||
m_exitCode = threadFunc(this);
|
||||
SetEvent(m_handle);
|
||||
}, CallbackContext::Any);
|
||||
|
||||
ThreadPool::RunAsync(workItemHandler, WorkItemPriority::Normal, WorkItemOptions::TimeSliced);
|
||||
#elif BX_PLATFORM_POSIX
|
||||
int result;
|
||||
BX_UNUSED(result);
|
||||
|
||||
pthread_attr_t attr;
|
||||
result = pthread_attr_init(&attr);
|
||||
BX_CHECK(0 == result, "pthread_attr_init failed! %d", result);
|
||||
|
||||
if (0 != m_stackSize)
|
||||
{
|
||||
result = pthread_attr_setstacksize(&attr, m_stackSize);
|
||||
BX_CHECK(0 == result, "pthread_attr_setstacksize failed! %d", result);
|
||||
}
|
||||
|
||||
// sched_param sched;
|
||||
// sched.sched_priority = 0;
|
||||
// result = pthread_attr_setschedparam(&attr, &sched);
|
||||
// BX_CHECK(0 == result, "pthread_attr_setschedparam failed! %d", result);
|
||||
|
||||
result = pthread_create(&m_handle, &attr, &threadFunc, this);
|
||||
BX_CHECK(0 == result, "pthread_attr_setschedparam failed! %d", result);
|
||||
#else
|
||||
# error "Not implemented!"
|
||||
#endif // BX_PLATFORM_
|
||||
|
||||
m_sem.wait();
|
||||
|
||||
if (NULL != _name)
|
||||
{
|
||||
setThreadName(_name);
|
||||
}
|
||||
}
|
||||
|
||||
void Thread::shutdown()
|
||||
{
|
||||
BX_CHECK(m_running, "Not running!");
|
||||
#if BX_PLATFORM_WINDOWS || BX_PLATFORM_XBOX360
|
||||
WaitForSingleObject(m_handle, INFINITE);
|
||||
GetExitCodeThread(m_handle, (DWORD*)&m_exitCode);
|
||||
CloseHandle(m_handle);
|
||||
m_handle = INVALID_HANDLE_VALUE;
|
||||
#elif BX_PLATFORM_WINRT
|
||||
WaitForSingleObjectEx(m_handle, INFINITE, FALSE);
|
||||
CloseHandle(m_handle);
|
||||
m_handle = INVALID_HANDLE_VALUE;
|
||||
#elif BX_PLATFORM_POSIX
|
||||
union
|
||||
{
|
||||
void* ptr;
|
||||
int32_t i;
|
||||
} cast;
|
||||
pthread_join(m_handle, &cast.ptr);
|
||||
m_exitCode = cast.i;
|
||||
m_handle = 0;
|
||||
#endif // BX_PLATFORM_
|
||||
m_running = false;
|
||||
}
|
||||
|
||||
bool Thread::isRunning() const
|
||||
{
|
||||
return m_running;
|
||||
}
|
||||
|
||||
int32_t Thread::getExitCode() const
|
||||
{
|
||||
return m_exitCode;
|
||||
}
|
||||
|
||||
void Thread::setThreadName(const char* _name)
|
||||
{
|
||||
#if BX_PLATFORM_OSX || BX_PLATFORM_IOS
|
||||
pthread_setname_np(_name);
|
||||
#elif (BX_CRT_GLIBC >= 21200) && ! BX_PLATFORM_HURD
|
||||
pthread_setname_np(m_handle, _name);
|
||||
#elif BX_PLATFORM_LINUX
|
||||
prctl(PR_SET_NAME,_name, 0, 0, 0);
|
||||
#elif BX_PLATFORM_BSD
|
||||
# ifdef __NetBSD__
|
||||
pthread_setname_np(m_handle, "%s", (void*)_name);
|
||||
# else
|
||||
pthread_set_name_np(m_handle, _name);
|
||||
# endif // __NetBSD__
|
||||
#elif BX_PLATFORM_WINDOWS && BX_COMPILER_MSVC
|
||||
# pragma pack(push, 8)
|
||||
struct ThreadName
|
||||
{
|
||||
DWORD type;
|
||||
LPCSTR name;
|
||||
DWORD id;
|
||||
DWORD flags;
|
||||
};
|
||||
# pragma pack(pop)
|
||||
ThreadName tn;
|
||||
tn.type = 0x1000;
|
||||
tn.name = _name;
|
||||
tn.id = m_threadId;
|
||||
tn.flags = 0;
|
||||
|
||||
__try
|
||||
{
|
||||
RaiseException(0x406d1388
|
||||
, 0
|
||||
, sizeof(tn)/4
|
||||
, reinterpret_cast<ULONG_PTR*>(&tn)
|
||||
);
|
||||
}
|
||||
__except(EXCEPTION_EXECUTE_HANDLER)
|
||||
{
|
||||
}
|
||||
#else
|
||||
BX_UNUSED(_name);
|
||||
#endif // BX_PLATFORM_
|
||||
}
|
||||
|
||||
int32_t Thread::entry()
|
||||
{
|
||||
#if BX_PLATFORM_WINDOWS
|
||||
m_threadId = ::GetCurrentThreadId();
|
||||
#endif // BX_PLATFORM_WINDOWS
|
||||
|
||||
m_sem.post();
|
||||
return m_fn(m_userData);
|
||||
}
|
||||
|
||||
#if BX_PLATFORM_WINDOWS || BX_PLATFORM_XBOX360 || BX_PLATFORM_WINRT
|
||||
DWORD WINAPI Thread::threadFunc(LPVOID _arg)
|
||||
{
|
||||
Thread* thread = (Thread*)_arg;
|
||||
int32_t result = thread->entry();
|
||||
return result;
|
||||
}
|
||||
#else
|
||||
void* Thread::threadFunc(void* _arg)
|
||||
{
|
||||
Thread* thread = (Thread*)_arg;
|
||||
union
|
||||
{
|
||||
void* ptr;
|
||||
int32_t i;
|
||||
} cast;
|
||||
cast.i = thread->entry();
|
||||
return cast.ptr;
|
||||
}
|
||||
#endif // BX_PLATFORM_
|
||||
|
||||
} // namespace bx
|
||||
|
||||
#endif // BX_CONFIG_SUPPORTS_THREADING
|
||||
Reference in New Issue
Block a user