rpcs3/Utilities/Thread.h

176 lines
2.9 KiB
C
Raw Normal View History

#pragma once
2014-07-11 11:59:13 +00:00
static std::thread::id main_thread;
class NamedThreadBase
{
2013-11-27 19:16:19 +00:00
std::string m_name;
std::condition_variable m_signal_cv;
std::mutex m_signal_mtx;
public:
2014-09-14 22:17:24 +00:00
std::atomic<bool> m_tls_assigned;
NamedThreadBase(const std::string& name) : m_name(name), m_tls_assigned(false)
{
}
2014-09-14 22:17:24 +00:00
NamedThreadBase() : m_tls_assigned(false)
{
}
2013-11-27 19:16:19 +00:00
virtual std::string GetThreadName() const;
virtual void SetThreadName(const std::string& name);
2014-09-12 19:27:33 +00:00
void WaitForAnySignal(u64 time = 1);
2014-08-25 18:09:48 +00:00
void Notify();
};
NamedThreadBase* GetCurrentNamedThread();
2014-08-20 14:23:48 +00:00
void SetCurrentNamedThread(NamedThreadBase* value);
class ThreadBase : public NamedThreadBase
{
protected:
std::atomic<bool> m_destroy;
std::atomic<bool> m_alive;
std::thread* m_executor;
mutable std::mutex m_main_mutex;
ThreadBase(const std::string& name);
~ThreadBase();
public:
void Start();
void Stop(bool wait = true, bool send_destroy = true);
bool Join() const;
bool IsAlive() const;
bool TestDestroy() const;
virtual void Task() = 0;
};
class thread
{
std::string m_name;
std::thread m_thr;
public:
thread(const std::string& name, std::function<void()> func);
thread(const std::string& name);
thread();
2014-02-19 17:27:52 +00:00
public:
void start(std::function<void()> func);
void detach();
void join();
bool joinable() const;
};
2014-10-17 20:13:25 +00:00
class s_mutex_t
{
};
class s_shared_mutex_t
{
};
class s_cond_var_t
{
//public:
// s_cond_var_t();
// ~s_cond_var_t();
//
// s_cond_var_t(s_cond_var_t& right) = delete;
// s_cond_var_t& operator = (s_cond_var_t& right) = delete;
//
// void wait();
// void wait_for();
//
// void notify();
// void notify_all();
};
class slw_mutex_t
{
};
class slw_recursive_mutex_t
{
};
class slw_shared_mutex_t
{
};
class waiter_map_t
2014-10-10 22:37:20 +00:00
{
// TODO: optimize (use custom lightweight readers-writer lock)
std::mutex m_mutex;
2014-10-10 22:37:20 +00:00
struct waiter_t
{
u64 signal_id;
NamedThreadBase* thread;
};
2014-10-10 22:37:20 +00:00
std::vector<waiter_t> m_waiters;
std::string m_name;
struct waiter_reg_t
{
2014-10-17 20:13:25 +00:00
NamedThreadBase* thread;
const u64 signal_id;
waiter_map_t& map;
2014-10-17 20:13:25 +00:00
waiter_reg_t(waiter_map_t& map, u64 signal_id)
: thread(nullptr)
, signal_id(signal_id)
, map(map)
{
}
~waiter_reg_t();
2014-10-17 20:13:25 +00:00
void init();
};
bool is_stopped(u64 signal_id);
public:
2014-10-17 20:13:25 +00:00
waiter_map_t(const char* name)
: m_name(name)
{
}
// wait until waiter_func() returns true, signal_id is an arbitrary number
2014-10-16 19:34:17 +00:00
template<typename WT> __forceinline void wait_op(u64 signal_id, const WT waiter_func)
{
// register waiter
waiter_reg_t waiter(*this, signal_id);
2014-10-17 20:13:25 +00:00
// check condition or if emulator is stopped
while (!waiter_func() && !is_stopped(signal_id))
{
2014-10-17 20:13:25 +00:00
// initialize waiter (only first time)
waiter.init();
// wait for 1 ms or until signal arrived
waiter.thread->WaitForAnySignal(1);
}
}
// signal all threads waiting on waiter_op() with the same signal_id (signaling only hints those threads that corresponding conditions are *probably* met)
void notify(u64 signal_id);
};