archive/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-07-16 03:38:38 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

More cleanup

Browse source
This commit is contained in:
Nekotekina 2015-03-07 19:03:42 +03:00
parent 961fc27215
commit 4a6ef91eb3
8 changed files with 104 additions and 163 deletions
Download patch file Download diff file Expand all files Collapse all files

53
Utilities/Thread.cpp
View file

@ -1472,63 +1472,12 @@ bool waiter_map_t::is_stopped(u64 signal_id)
{
if (Emu.IsStopped())
{
LOG_WARNING(Log::HLE, "%s: waiter_op() aborted (signal_id=0x%llx)", m_name.c_str(), signal_id);
LOG_WARNING(Log::HLE, "%s: waiter_op() aborted (signal_id=0x%llx)", name.c_str(), signal_id);
return true;
}
return false;
}
void waiter_map_t::waiter_reg_t::init()
{
if (!thread)
{
thread = GetCurrentNamedThread();
std::lock_guard<std::mutex> lock(map.m_mutex);
// add waiter
map.m_waiters.push_back({ signal_id, thread });
}
}
waiter_map_t::waiter_reg_t::~waiter_reg_t()
{
if (thread)
{
std::lock_guard<std::mutex> lock(map.m_mutex);
// remove waiter
for (s64 i = map.m_waiters.size() - 1; i >= 0; i--)
{
if (map.m_waiters[i].signal_id == signal_id && map.m_waiters[i].thread == thread)
{
map.m_waiters.erase(map.m_waiters.begin() + i);
return;
}
}
LOG_ERROR(HLE, "%s(): waiter not found (signal_id=0x%llx, map='%s')", __FUNCTION__, signal_id, map.m_name.c_str());
Emu.Pause();
}
}
void waiter_map_t::notify(u64 signal_id)
{
if (m_waiters.size())
{
std::lock_guard<std::mutex> lock(m_mutex);
// find waiter and signal
for (auto& v : m_waiters)
{
if (v.signal_id == signal_id)
{
v.thread->Notify();
}
}
}
}
const std::function<bool()> SQUEUE_ALWAYS_EXIT = [](){ return true; };
const std::function<bool()> SQUEUE_NEVER_EXIT = [](){ return false; };

71
Utilities/Thread.h
View file

@ -103,65 +103,54 @@ class slw_shared_mutex_t
};
class waiter_map_t
struct waiter_map_t
{
// TODO: optimize (use custom lightweight readers-writer lock)
std::mutex m_mutex;
static const size_t size = 32;
struct waiter_t
{
u64 signal_id;
NamedThreadBase* thread;
};
std::array<std::mutex, size> mutex;
std::array<std::condition_variable, size> cv;
std::vector<waiter_t> m_waiters;
const std::string name;
std::string m_name;
struct waiter_reg_t
{
NamedThreadBase* thread;
const u64 signal_id;
waiter_map_t& map;
waiter_reg_t(waiter_map_t& map, u64 signal_id)
: thread(nullptr)
, signal_id(signal_id)
, map(map)
{
}
~waiter_reg_t();
void init();
};
bool is_stopped(u64 signal_id);
public:
waiter_map_t(const char* name)
: m_name(name)
: name(name)
{
}
bool is_stopped(u64 signal_id);
// wait until waiter_func() returns true, signal_id is an arbitrary number
template<typename WT> __forceinline void wait_op(u64 signal_id, const WT waiter_func)
template<typename S, typename WT> __forceinline __safebuffers void wait_op(const S& signal_id, const WT waiter_func)
{
// register waiter
waiter_reg_t waiter(*this, signal_id);
// generate hash
const auto hash = std::hash<S>()(signal_id) % size;
// set mutex locker
std::unique_lock<std::mutex> locker(mutex[hash], std::defer_lock);
// check the condition or if the emulator is stopped
while (!waiter_func() && !is_stopped(signal_id))
{
// initialize waiter (only once)
waiter.init();
// wait for 1 ms or until signal arrived
waiter.thread->WaitForAnySignal(1);
// lock the mutex and initialize waiter (only once)
if (!locker.owns_lock())
{
locker.lock();
}
// wait on appropriate condition variable for 1 ms or until signal arrived
cv[hash].wait_for(locker, std::chrono::milliseconds(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);
template<typename S> __forceinline void notify(const S& signal_id)
{
// generate hash
const auto hash = std::hash<S>()(signal_id) % size;
// signal appropriate condition variable
cv[hash].notify_all();
}
};
extern const std::function<bool()> SQUEUE_ALWAYS_EXIT;