mirror of
https://github.com/citra-emu/citra.git
synced 2024-11-26 07:40:05 +00:00
Removed common/std_xyz, instead using the std header
This commit is contained in:
archshift
parent
5d95d038a0
commit
498d1a37f1
@ -49,9 +49,6 @@ set(HEADERS
|
|||||||
msg_handler.h
|
msg_handler.h
|
||||||
platform.h
|
platform.h
|
||||||
scm_rev.h
|
scm_rev.h
|
||||||
std_condition_variable.h
|
|
||||||
std_mutex.h
|
|
||||||
std_thread.h
|
|
||||||
string_util.h
|
string_util.h
|
||||||
swap.h
|
swap.h
|
||||||
symbols.h
|
symbols.h
|
||||||
|
|||||||
@ -6,11 +6,11 @@
|
|||||||
|
|
||||||
#include "common/log.h"
|
#include "common/log.h"
|
||||||
#include "common/string_util.h"
|
#include "common/string_util.h"
|
||||||
#include "common/thread.h"
|
|
||||||
#include "common/file_util.h"
|
#include "common/file_util.h"
|
||||||
|
|
||||||
#include <cstring>
|
#include <cstring>
|
||||||
#include <set>
|
#include <set>
|
||||||
|
#include <mutex>
|
||||||
|
|
||||||
#define MAX_MESSAGES 8000
|
#define MAX_MESSAGES 8000
|
||||||
#define MAX_MSGLEN 1024
|
#define MAX_MSGLEN 1024
|
||||||
|
|||||||
@ -1,168 +0,0 @@
|
|||||||
|
|
||||||
#pragma once
|
|
||||||
|
|
||||||
#define GCC_VER(x,y,z) ((x) * 10000 + (y) * 100 + (z))
|
|
||||||
#define GCC_VERSION GCC_VER(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
|
|
||||||
|
|
||||||
#ifndef __has_include
|
|
||||||
#define __has_include(s) 0
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if GCC_VERSION >= GCC_VER(4,4,0) && __GXX_EXPERIMENTAL_CXX0X__
|
|
||||||
|
|
||||||
// GCC 4.4 provides <condition_variable>
|
|
||||||
#include <condition_variable>
|
|
||||||
|
|
||||||
#elif __has_include(<condition_variable>) && !ANDROID
|
|
||||||
|
|
||||||
// clang and libc++ provide <condition_variable> on OSX. However, the version
|
|
||||||
// of libc++ bundled with OSX 10.7 and 10.8 is buggy: it uses _ as a variable.
|
|
||||||
//
|
|
||||||
// We work around this issue by undefining and redefining _.
|
|
||||||
|
|
||||||
#undef _
|
|
||||||
#include <condition_variable>
|
|
||||||
#define _(s) wxGetTranslation((s))
|
|
||||||
|
|
||||||
#else
|
|
||||||
|
|
||||||
// partial std::condition_variable implementation for win32/pthread
|
|
||||||
|
|
||||||
#include "common/std_mutex.h"
|
|
||||||
|
|
||||||
#if (_MSC_VER >= 1600) || (GCC_VERSION >= GCC_VER(4,3,0) && __GXX_EXPERIMENTAL_CXX0X__)
|
|
||||||
#define USE_RVALUE_REFERENCES
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(_WIN32) && defined(_M_X64)
|
|
||||||
#define USE_CONDITION_VARIABLES
|
|
||||||
#elif defined(_WIN32)
|
|
||||||
#define USE_EVENTS
|
|
||||||
#endif
|
|
||||||
|
|
||||||
namespace std
|
|
||||||
{
|
|
||||||
|
|
||||||
class condition_variable
|
|
||||||
{
|
|
||||||
#if defined(_WIN32) && defined(USE_CONDITION_VARIABLES)
|
|
||||||
typedef CONDITION_VARIABLE native_type;
|
|
||||||
#elif defined(_WIN32)
|
|
||||||
typedef HANDLE native_type;
|
|
||||||
#else
|
|
||||||
typedef pthread_cond_t native_type;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
public:
|
|
||||||
|
|
||||||
#ifdef USE_EVENTS
|
|
||||||
typedef native_type native_handle_type;
|
|
||||||
#else
|
|
||||||
typedef native_type* native_handle_type;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
condition_variable()
|
|
||||||
{
|
|
||||||
#if defined(_WIN32) && defined(USE_CONDITION_VARIABLES)
|
|
||||||
InitializeConditionVariable(&m_handle);
|
|
||||||
#elif defined(_WIN32)
|
|
||||||
m_handle = CreateEvent(NULL, false, false, NULL);
|
|
||||||
#else
|
|
||||||
pthread_cond_init(&m_handle, NULL);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
~condition_variable()
|
|
||||||
{
|
|
||||||
#if defined(_WIN32) && !defined(USE_CONDITION_VARIABLES)
|
|
||||||
CloseHandle(m_handle);
|
|
||||||
#elif !defined(_WIN32)
|
|
||||||
pthread_cond_destroy(&m_handle);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
condition_variable(const condition_variable&) /*= delete*/;
|
|
||||||
condition_variable& operator=(const condition_variable&) /*= delete*/;
|
|
||||||
|
|
||||||
void notify_one()
|
|
||||||
{
|
|
||||||
#if defined(_WIN32) && defined(USE_CONDITION_VARIABLES)
|
|
||||||
WakeConditionVariable(&m_handle);
|
|
||||||
#elif defined(_WIN32)
|
|
||||||
SetEvent(m_handle);
|
|
||||||
#else
|
|
||||||
pthread_cond_signal(&m_handle);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
void notify_all()
|
|
||||||
{
|
|
||||||
#if defined(_WIN32) && defined(USE_CONDITION_VARIABLES)
|
|
||||||
WakeAllConditionVariable(&m_handle);
|
|
||||||
#elif defined(_WIN32)
|
|
||||||
// TODO: broken
|
|
||||||
SetEvent(m_handle);
|
|
||||||
#else
|
|
||||||
pthread_cond_broadcast(&m_handle);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
void wait(unique_lock<mutex>& lock)
|
|
||||||
{
|
|
||||||
#ifdef _WIN32
|
|
||||||
#ifdef USE_SRWLOCKS
|
|
||||||
SleepConditionVariableSRW(&m_handle, lock.mutex()->native_handle(), INFINITE, 0);
|
|
||||||
#elif defined(USE_CONDITION_VARIABLES)
|
|
||||||
SleepConditionVariableCS(&m_handle, lock.mutex()->native_handle(), INFINITE);
|
|
||||||
#else
|
|
||||||
// TODO: broken, the unlock and wait need to be atomic
|
|
||||||
lock.unlock();
|
|
||||||
WaitForSingleObject(m_handle, INFINITE);
|
|
||||||
lock.lock();
|
|
||||||
#endif
|
|
||||||
#else
|
|
||||||
pthread_cond_wait(&m_handle, lock.mutex()->native_handle());
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
template <class Predicate>
|
|
||||||
void wait(unique_lock<mutex>& lock, Predicate pred)
|
|
||||||
{
|
|
||||||
while (!pred())
|
|
||||||
wait(lock);
|
|
||||||
}
|
|
||||||
|
|
||||||
//template <class Clock, class Duration>
|
|
||||||
//cv_status wait_until(unique_lock<mutex>& lock,
|
|
||||||
// const chrono::time_point<Clock, Duration>& abs_time);
|
|
||||||
|
|
||||||
//template <class Clock, class Duration, class Predicate>
|
|
||||||
// bool wait_until(unique_lock<mutex>& lock,
|
|
||||||
// const chrono::time_point<Clock, Duration>& abs_time,
|
|
||||||
// Predicate pred);
|
|
||||||
|
|
||||||
//template <class Rep, class Period>
|
|
||||||
//cv_status wait_for(unique_lock<mutex>& lock,
|
|
||||||
// const chrono::duration<Rep, Period>& rel_time);
|
|
||||||
|
|
||||||
//template <class Rep, class Period, class Predicate>
|
|
||||||
// bool wait_for(unique_lock<mutex>& lock,
|
|
||||||
// const chrono::duration<Rep, Period>& rel_time,
|
|
||||||
// Predicate pred);
|
|
||||||
|
|
||||||
native_handle_type native_handle()
|
|
||||||
{
|
|
||||||
#ifdef USE_EVENTS
|
|
||||||
return m_handle;
|
|
||||||
#else
|
|
||||||
return &m_handle;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
native_type m_handle;
|
|
||||||
};
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@ -1,362 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
|
|
||||||
#define GCC_VER(x,y,z) ((x) * 10000 + (y) * 100 + (z))
|
|
||||||
#define GCC_VERSION GCC_VER(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
|
|
||||||
|
|
||||||
#ifndef __has_include
|
|
||||||
#define __has_include(s) 0
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if GCC_VERSION >= GCC_VER(4,4,0) && __GXX_EXPERIMENTAL_CXX0X__
|
|
||||||
// GCC 4.4 provides <mutex>
|
|
||||||
#include <mutex>
|
|
||||||
#elif __has_include(<mutex>) && !ANDROID
|
|
||||||
// Clang + libc++
|
|
||||||
#include <mutex>
|
|
||||||
#else
|
|
||||||
|
|
||||||
// partial <mutex> implementation for win32/pthread
|
|
||||||
|
|
||||||
#include <algorithm>
|
|
||||||
|
|
||||||
#if defined(_WIN32)
|
|
||||||
// WIN32
|
|
||||||
#define WIN32_LEAN_AND_MEAN
|
|
||||||
#include <Windows.h>
|
|
||||||
|
|
||||||
#else
|
|
||||||
// POSIX
|
|
||||||
#include <pthread.h>
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if (_MSC_VER >= 1600) || (GCC_VERSION >= GCC_VER(4,3,0) && __GXX_EXPERIMENTAL_CXX0X__)
|
|
||||||
#define USE_RVALUE_REFERENCES
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(_WIN32) && defined(_M_X64)
|
|
||||||
#define USE_SRWLOCKS
|
|
||||||
#endif
|
|
||||||
|
|
||||||
namespace std
|
|
||||||
{
|
|
||||||
|
|
||||||
class recursive_mutex
|
|
||||||
{
|
|
||||||
#ifdef _WIN32
|
|
||||||
typedef CRITICAL_SECTION native_type;
|
|
||||||
#else
|
|
||||||
typedef pthread_mutex_t native_type;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
public:
|
|
||||||
typedef native_type* native_handle_type;
|
|
||||||
|
|
||||||
recursive_mutex(const recursive_mutex&) /*= delete*/;
|
|
||||||
recursive_mutex& operator=(const recursive_mutex&) /*= delete*/;
|
|
||||||
|
|
||||||
recursive_mutex()
|
|
||||||
{
|
|
||||||
#ifdef _WIN32
|
|
||||||
InitializeCriticalSection(&m_handle);
|
|
||||||
#else
|
|
||||||
pthread_mutexattr_t attr;
|
|
||||||
pthread_mutexattr_init(&attr);
|
|
||||||
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
|
|
||||||
pthread_mutex_init(&m_handle, &attr);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
~recursive_mutex()
|
|
||||||
{
|
|
||||||
#ifdef _WIN32
|
|
||||||
DeleteCriticalSection(&m_handle);
|
|
||||||
#else
|
|
||||||
pthread_mutex_destroy(&m_handle);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
void lock()
|
|
||||||
{
|
|
||||||
#ifdef _WIN32
|
|
||||||
EnterCriticalSection(&m_handle);
|
|
||||||
#else
|
|
||||||
pthread_mutex_lock(&m_handle);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
void unlock()
|
|
||||||
{
|
|
||||||
#ifdef _WIN32
|
|
||||||
LeaveCriticalSection(&m_handle);
|
|
||||||
#else
|
|
||||||
pthread_mutex_unlock(&m_handle);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
bool try_lock()
|
|
||||||
{
|
|
||||||
#ifdef _WIN32
|
|
||||||
return (0 != TryEnterCriticalSection(&m_handle));
|
|
||||||
#else
|
|
||||||
return !pthread_mutex_trylock(&m_handle);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
native_handle_type native_handle()
|
|
||||||
{
|
|
||||||
return &m_handle;
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
native_type m_handle;
|
|
||||||
};
|
|
||||||
|
|
||||||
#if !defined(_WIN32) || defined(USE_SRWLOCKS)
|
|
||||||
|
|
||||||
class mutex
|
|
||||||
{
|
|
||||||
#ifdef _WIN32
|
|
||||||
typedef SRWLOCK native_type;
|
|
||||||
#else
|
|
||||||
typedef pthread_mutex_t native_type;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
public:
|
|
||||||
typedef native_type* native_handle_type;
|
|
||||||
|
|
||||||
mutex(const mutex&) /*= delete*/;
|
|
||||||
mutex& operator=(const mutex&) /*= delete*/;
|
|
||||||
|
|
||||||
mutex()
|
|
||||||
{
|
|
||||||
#ifdef _WIN32
|
|
||||||
InitializeSRWLock(&m_handle);
|
|
||||||
#else
|
|
||||||
pthread_mutex_init(&m_handle, NULL);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
~mutex()
|
|
||||||
{
|
|
||||||
#ifdef _WIN32
|
|
||||||
#else
|
|
||||||
pthread_mutex_destroy(&m_handle);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
void lock()
|
|
||||||
{
|
|
||||||
#ifdef _WIN32
|
|
||||||
AcquireSRWLockExclusive(&m_handle);
|
|
||||||
#else
|
|
||||||
pthread_mutex_lock(&m_handle);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
void unlock()
|
|
||||||
{
|
|
||||||
#ifdef _WIN32
|
|
||||||
ReleaseSRWLockExclusive(&m_handle);
|
|
||||||
#else
|
|
||||||
pthread_mutex_unlock(&m_handle);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
bool try_lock()
|
|
||||||
{
|
|
||||||
#ifdef _WIN32
|
|
||||||
// XXX TryAcquireSRWLockExclusive requires Windows 7!
|
|
||||||
// return (0 != TryAcquireSRWLockExclusive(&m_handle));
|
|
||||||
return false;
|
|
||||||
#else
|
|
||||||
return !pthread_mutex_trylock(&m_handle);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
native_handle_type native_handle()
|
|
||||||
{
|
|
||||||
return &m_handle;
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
native_type m_handle;
|
|
||||||
};
|
|
||||||
|
|
||||||
#else
|
|
||||||
typedef recursive_mutex mutex; // just use CriticalSections
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
enum defer_lock_t { defer_lock };
|
|
||||||
enum try_to_lock_t { try_to_lock };
|
|
||||||
enum adopt_lock_t { adopt_lock };
|
|
||||||
|
|
||||||
template <class Mutex>
|
|
||||||
class lock_guard
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
typedef Mutex mutex_type;
|
|
||||||
|
|
||||||
explicit lock_guard(mutex_type& m)
|
|
||||||
: pm(m)
|
|
||||||
{
|
|
||||||
m.lock();
|
|
||||||
}
|
|
||||||
|
|
||||||
lock_guard(mutex_type& m, adopt_lock_t)
|
|
||||||
: pm(m)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
~lock_guard()
|
|
||||||
{
|
|
||||||
pm.unlock();
|
|
||||||
}
|
|
||||||
|
|
||||||
lock_guard(lock_guard const&) /*= delete*/;
|
|
||||||
lock_guard& operator=(lock_guard const&) /*= delete*/;
|
|
||||||
|
|
||||||
private:
|
|
||||||
mutex_type& pm;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class Mutex>
|
|
||||||
class unique_lock
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
typedef Mutex mutex_type;
|
|
||||||
|
|
||||||
unique_lock()
|
|
||||||
: pm(NULL), owns(false)
|
|
||||||
{}
|
|
||||||
|
|
||||||
/*explicit*/ unique_lock(mutex_type& m)
|
|
||||||
: pm(&m), owns(true)
|
|
||||||
{
|
|
||||||
m.lock();
|
|
||||||
}
|
|
||||||
|
|
||||||
unique_lock(mutex_type& m, defer_lock_t)
|
|
||||||
: pm(&m), owns(false)
|
|
||||||
{}
|
|
||||||
|
|
||||||
unique_lock(mutex_type& m, try_to_lock_t)
|
|
||||||
: pm(&m), owns(m.try_lock())
|
|
||||||
{}
|
|
||||||
|
|
||||||
unique_lock(mutex_type& m, adopt_lock_t)
|
|
||||||
: pm(&m), owns(true)
|
|
||||||
{}
|
|
||||||
|
|
||||||
//template <class Clock, class Duration>
|
|
||||||
//unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
|
|
||||||
|
|
||||||
//template <class Rep, class Period>
|
|
||||||
//unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
|
|
||||||
|
|
||||||
~unique_lock()
|
|
||||||
{
|
|
||||||
if (owns_lock())
|
|
||||||
mutex()->unlock();
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef USE_RVALUE_REFERENCES
|
|
||||||
unique_lock& operator=(const unique_lock&) /*= delete*/;
|
|
||||||
|
|
||||||
unique_lock& operator=(unique_lock&& other)
|
|
||||||
{
|
|
||||||
#else
|
|
||||||
unique_lock& operator=(const unique_lock& u)
|
|
||||||
{
|
|
||||||
// ugly const_cast to get around lack of rvalue references
|
|
||||||
unique_lock& other = const_cast<unique_lock&>(u);
|
|
||||||
#endif
|
|
||||||
swap(other);
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef USE_RVALUE_REFERENCES
|
|
||||||
unique_lock(const unique_lock&) /*= delete*/;
|
|
||||||
|
|
||||||
unique_lock(unique_lock&& other)
|
|
||||||
: pm(NULL), owns(false)
|
|
||||||
{
|
|
||||||
#else
|
|
||||||
unique_lock(const unique_lock& u)
|
|
||||||
: pm(NULL), owns(false)
|
|
||||||
{
|
|
||||||
// ugly const_cast to get around lack of rvalue references
|
|
||||||
unique_lock& other = const_cast<unique_lock&>(u);
|
|
||||||
#endif
|
|
||||||
swap(other);
|
|
||||||
}
|
|
||||||
|
|
||||||
void lock()
|
|
||||||
{
|
|
||||||
mutex()->lock();
|
|
||||||
owns = true;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool try_lock()
|
|
||||||
{
|
|
||||||
owns = mutex()->try_lock();
|
|
||||||
return owns;
|
|
||||||
}
|
|
||||||
|
|
||||||
//template <class Rep, class Period>
|
|
||||||
//bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
|
|
||||||
//template <class Clock, class Duration>
|
|
||||||
//bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
|
|
||||||
|
|
||||||
void unlock()
|
|
||||||
{
|
|
||||||
mutex()->unlock();
|
|
||||||
owns = false;
|
|
||||||
}
|
|
||||||
|
|
||||||
void swap(unique_lock& u)
|
|
||||||
{
|
|
||||||
std::swap(pm, u.pm);
|
|
||||||
std::swap(owns, u.owns);
|
|
||||||
}
|
|
||||||
|
|
||||||
mutex_type* release()
|
|
||||||
{
|
|
||||||
auto const ret = mutex();
|
|
||||||
|
|
||||||
pm = NULL;
|
|
||||||
owns = false;
|
|
||||||
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool owns_lock() const
|
|
||||||
{
|
|
||||||
return owns;
|
|
||||||
}
|
|
||||||
|
|
||||||
//explicit operator bool () const
|
|
||||||
//{
|
|
||||||
// return owns_lock();
|
|
||||||
//}
|
|
||||||
|
|
||||||
mutex_type* mutex() const
|
|
||||||
{
|
|
||||||
return pm;
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
mutex_type* pm;
|
|
||||||
bool owns;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class Mutex>
|
|
||||||
void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y)
|
|
||||||
{
|
|
||||||
x.swap(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@ -1,314 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
|
|
||||||
#define GCC_VER(x,y,z) ((x) * 10000 + (y) * 100 + (z))
|
|
||||||
#define GCC_VERSION GCC_VER(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
|
|
||||||
|
|
||||||
#ifndef __has_include
|
|
||||||
#define __has_include(s) 0
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if GCC_VERSION >= GCC_VER(4,4,0) && __GXX_EXPERIMENTAL_CXX0X__
|
|
||||||
// GCC 4.4 provides <thread>
|
|
||||||
#ifndef _GLIBCXX_USE_SCHED_YIELD
|
|
||||||
#define _GLIBCXX_USE_SCHED_YIELD
|
|
||||||
#endif
|
|
||||||
#include <thread>
|
|
||||||
#elif __has_include(<thread>) && !ANDROID
|
|
||||||
// Clang + libc++
|
|
||||||
#include <thread>
|
|
||||||
#else
|
|
||||||
|
|
||||||
// partial std::thread implementation for win32/pthread
|
|
||||||
|
|
||||||
#include <algorithm>
|
|
||||||
|
|
||||||
#if (_MSC_VER >= 1600) || (GCC_VERSION >= GCC_VER(4,3,0) && __GXX_EXPERIMENTAL_CXX0X__)
|
|
||||||
#define USE_RVALUE_REFERENCES
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef __APPLE__
|
|
||||||
#import <Foundation/NSAutoreleasePool.h>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(_WIN32)
|
|
||||||
// WIN32
|
|
||||||
|
|
||||||
#define WIN32_LEAN_AND_MEAN
|
|
||||||
#include <Windows.h>
|
|
||||||
|
|
||||||
#if defined(_MSC_VER) && defined(_MT)
|
|
||||||
// When linking with LIBCMT (the multithreaded C library), Microsoft recommends
|
|
||||||
// using _beginthreadex instead of CreateThread.
|
|
||||||
#define USE_BEGINTHREADEX
|
|
||||||
#include <process.h>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef USE_BEGINTHREADEX
|
|
||||||
#define THREAD_ID unsigned
|
|
||||||
#define THREAD_RETURN unsigned __stdcall
|
|
||||||
#else
|
|
||||||
#define THREAD_ID DWORD
|
|
||||||
#define THREAD_RETURN DWORD WINAPI
|
|
||||||
#endif
|
|
||||||
#define THREAD_HANDLE HANDLE
|
|
||||||
|
|
||||||
#else
|
|
||||||
// PTHREAD
|
|
||||||
|
|
||||||
#include <unistd.h>
|
|
||||||
|
|
||||||
#ifndef _POSIX_THREADS
|
|
||||||
#error unsupported platform (no pthreads?)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#include <pthread.h>
|
|
||||||
|
|
||||||
#define THREAD_ID pthread_t
|
|
||||||
#define THREAD_HANDLE pthread_t
|
|
||||||
#define THREAD_RETURN void*
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
namespace std
|
|
||||||
{
|
|
||||||
|
|
||||||
class thread
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
typedef THREAD_HANDLE native_handle_type;
|
|
||||||
|
|
||||||
class id
|
|
||||||
{
|
|
||||||
friend class thread;
|
|
||||||
public:
|
|
||||||
id() : m_thread(0) {}
|
|
||||||
id(THREAD_ID _id) : m_thread(_id) {}
|
|
||||||
|
|
||||||
bool operator==(const id& rhs) const
|
|
||||||
{
|
|
||||||
return m_thread == rhs.m_thread;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool operator!=(const id& rhs) const
|
|
||||||
{
|
|
||||||
return !(*this == rhs);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool operator<(const id& rhs) const
|
|
||||||
{
|
|
||||||
return m_thread < rhs.m_thread;
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
THREAD_ID m_thread;
|
|
||||||
};
|
|
||||||
|
|
||||||
// no variadic template support in msvc
|
|
||||||
//template <typename C, typename... A>
|
|
||||||
//thread(C&& func, A&&... args);
|
|
||||||
|
|
||||||
template <typename C>
|
|
||||||
thread(C func)
|
|
||||||
{
|
|
||||||
StartThread(new Func<C>(func));
|
|
||||||
}
|
|
||||||
|
|
||||||
template <typename C, typename A>
|
|
||||||
thread(C func, A arg)
|
|
||||||
{
|
|
||||||
StartThread(new FuncArg<C, A>(func, arg));
|
|
||||||
}
|
|
||||||
|
|
||||||
thread() /*= default;*/ {}
|
|
||||||
|
|
||||||
#ifdef USE_RVALUE_REFERENCES
|
|
||||||
thread(const thread&) /*= delete*/;
|
|
||||||
|
|
||||||
thread(thread&& other)
|
|
||||||
{
|
|
||||||
#else
|
|
||||||
thread(const thread& t)
|
|
||||||
{
|
|
||||||
// ugly const_cast to get around lack of rvalue references
|
|
||||||
thread& other = const_cast<thread&>(t);
|
|
||||||
#endif
|
|
||||||
swap(other);
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef USE_RVALUE_REFERENCES
|
|
||||||
thread& operator=(const thread&) /*= delete*/;
|
|
||||||
|
|
||||||
thread& operator=(thread&& other)
|
|
||||||
{
|
|
||||||
#else
|
|
||||||
thread& operator=(const thread& t)
|
|
||||||
{
|
|
||||||
// ugly const_cast to get around lack of rvalue references
|
|
||||||
thread& other = const_cast<thread&>(t);
|
|
||||||
#endif
|
|
||||||
if (joinable())
|
|
||||||
detach();
|
|
||||||
swap(other);
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
~thread()
|
|
||||||
{
|
|
||||||
if (joinable())
|
|
||||||
detach();
|
|
||||||
}
|
|
||||||
|
|
||||||
bool joinable() const
|
|
||||||
{
|
|
||||||
return m_id != id();
|
|
||||||
}
|
|
||||||
|
|
||||||
id get_id() const
|
|
||||||
{
|
|
||||||
return m_id;
|
|
||||||
}
|
|
||||||
|
|
||||||
native_handle_type native_handle()
|
|
||||||
{
|
|
||||||
#ifdef _WIN32
|
|
||||||
return m_handle;
|
|
||||||
#else
|
|
||||||
return m_id.m_thread;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
void join()
|
|
||||||
{
|
|
||||||
#ifdef _WIN32
|
|
||||||
WaitForSingleObject(m_handle, INFINITE);
|
|
||||||
detach();
|
|
||||||
#else
|
|
||||||
pthread_join(m_id.m_thread, NULL);
|
|
||||||
m_id = id();
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
void detach()
|
|
||||||
{
|
|
||||||
#ifdef _WIN32
|
|
||||||
CloseHandle(m_handle);
|
|
||||||
#else
|
|
||||||
pthread_detach(m_id.m_thread);
|
|
||||||
#endif
|
|
||||||
m_id = id();
|
|
||||||
}
|
|
||||||
|
|
||||||
void swap(thread& other)
|
|
||||||
{
|
|
||||||
std::swap(m_id, other.m_id);
|
|
||||||
#ifdef _WIN32
|
|
||||||
std::swap(m_handle, other.m_handle);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
static unsigned hardware_concurrency()
|
|
||||||
{
|
|
||||||
#ifdef _WIN32
|
|
||||||
SYSTEM_INFO sysinfo;
|
|
||||||
GetSystemInfo(&sysinfo);
|
|
||||||
return static_cast<unsigned>(sysinfo.dwNumberOfProcessors);
|
|
||||||
#else
|
|
||||||
return 0;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
id m_id;
|
|
||||||
|
|
||||||
#ifdef _WIN32
|
|
||||||
native_handle_type m_handle;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
template <typename F>
|
|
||||||
void StartThread(F* param)
|
|
||||||
{
|
|
||||||
#ifdef USE_BEGINTHREADEX
|
|
||||||
m_handle = (HANDLE)_beginthreadex(NULL, 0, &RunAndDelete<F>, param, 0, &m_id.m_thread);
|
|
||||||
#elif defined(_WIN32)
|
|
||||||
m_handle = CreateThread(NULL, 0, &RunAndDelete<F>, param, 0, &m_id.m_thread);
|
|
||||||
#else
|
|
||||||
pthread_attr_t attr;
|
|
||||||
pthread_attr_init(&attr);
|
|
||||||
pthread_attr_setstacksize(&attr, 1024 * 1024);
|
|
||||||
if (pthread_create(&m_id.m_thread, &attr, &RunAndDelete<F>, param))
|
|
||||||
m_id = id();
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
template <typename C>
|
|
||||||
class Func
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
Func(C _func) : func(_func) {}
|
|
||||||
|
|
||||||
void Run() { func(); }
|
|
||||||
|
|
||||||
private:
|
|
||||||
C const func;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <typename C, typename A>
|
|
||||||
class FuncArg
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
FuncArg(C _func, A _arg) : func(_func), arg(_arg) {}
|
|
||||||
|
|
||||||
void Run() { func(arg); }
|
|
||||||
|
|
||||||
private:
|
|
||||||
C const func;
|
|
||||||
A arg;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <typename F>
|
|
||||||
static THREAD_RETURN RunAndDelete(void* param)
|
|
||||||
{
|
|
||||||
#ifdef __APPLE__
|
|
||||||
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
|
|
||||||
#endif
|
|
||||||
static_cast<F*>(param)->Run();
|
|
||||||
delete static_cast<F*>(param);
|
|
||||||
#ifdef __APPLE__
|
|
||||||
[pool release];
|
|
||||||
#endif
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
namespace this_thread
|
|
||||||
{
|
|
||||||
|
|
||||||
inline void yield()
|
|
||||||
{
|
|
||||||
#ifdef _WIN32
|
|
||||||
SwitchToThread();
|
|
||||||
#else
|
|
||||||
sleep(0);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
inline thread::id get_id()
|
|
||||||
{
|
|
||||||
#ifdef _WIN32
|
|
||||||
return GetCurrentThreadId();
|
|
||||||
#else
|
|
||||||
return pthread_self();
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
} // namespace this_thread
|
|
||||||
|
|
||||||
} // namespace std
|
|
||||||
|
|
||||||
#undef USE_RVALUE_REFERENCES
|
|
||||||
#undef USE_BEGINTHREADEX
|
|
||||||
#undef THREAD_ID
|
|
||||||
#undef THREAD_RETURN
|
|
||||||
#undef THREAD_HANDLE
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@ -9,10 +9,8 @@
|
|||||||
#include <mach/mach.h>
|
#include <mach/mach.h>
|
||||||
#elif defined(BSD4_4) || defined(__OpenBSD__)
|
#elif defined(BSD4_4) || defined(__OpenBSD__)
|
||||||
#include <pthread_np.h>
|
#include <pthread_np.h>
|
||||||
#endif
|
#elif defined(_WIN32)
|
||||||
|
#include <Windows.h>
|
||||||
#ifdef USE_BEGINTHREADEX
|
|
||||||
#include <process.h>
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
namespace Common
|
namespace Common
|
||||||
|
|||||||
@ -4,14 +4,13 @@
|
|||||||
|
|
||||||
#pragma once
|
#pragma once
|
||||||
|
|
||||||
#include "common/std_condition_variable.h"
|
|
||||||
#include "common/std_mutex.h"
|
|
||||||
#include "common/std_thread.h"
|
|
||||||
|
|
||||||
// Don't include common.h here as it will break LogManager
|
// Don't include common.h here as it will break LogManager
|
||||||
#include "common/common_types.h"
|
#include "common/common_types.h"
|
||||||
#include <cstdio>
|
#include <cstdio>
|
||||||
#include <cstring>
|
#include <cstring>
|
||||||
|
#include <thread>
|
||||||
|
#include <condition_variable>
|
||||||
|
#include <mutex>
|
||||||
|
|
||||||
// This may not be defined outside _WIN32
|
// This may not be defined outside _WIN32
|
||||||
#ifndef _WIN32
|
#ifndef _WIN32
|
||||||
|
|||||||
@ -5,9 +5,9 @@
|
|||||||
#include <vector>
|
#include <vector>
|
||||||
#include <cstdio>
|
#include <cstdio>
|
||||||
#include <atomic>
|
#include <atomic>
|
||||||
|
#include <mutex>
|
||||||
|
|
||||||
#include "common/msg_handler.h"
|
#include "common/msg_handler.h"
|
||||||
#include "common/std_mutex.h"
|
|
||||||
#include "common/chunk_file.h"
|
#include "common/chunk_file.h"
|
||||||
|
|
||||||
#include "core/core_timing.h"
|
#include "core/core_timing.h"
|
||||||
|
|||||||
Loading…
Reference in New Issue
Block a user