mirror of
https://gitlab.com/suyu-emu/suyu.git
synced 2024-03-15 23:15:44 +00:00
781ab8407b
Since C++17, the introduction of deduction guides for locking facilities means that we no longer need to hardcode the mutex type into the locks themselves, making it easier to switch mutex types, should it ever be necessary in the future.
83 lines
2 KiB
C++
83 lines
2 KiB
C++
// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
|
|
// Licensed under GPLv2 or any later version
|
|
// Refer to the license.txt file included.
|
|
|
|
#pragma once
|
|
|
|
#include <chrono>
|
|
#include <condition_variable>
|
|
#include <cstddef>
|
|
#include <mutex>
|
|
#include <thread>
|
|
|
|
namespace Common {
|
|
|
|
class Event {
|
|
public:
|
|
void Set() {
|
|
std::lock_guard lk{mutex};
|
|
if (!is_set) {
|
|
is_set = true;
|
|
condvar.notify_one();
|
|
}
|
|
}
|
|
|
|
void Wait() {
|
|
std::unique_lock lk{mutex};
|
|
condvar.wait(lk, [&] { return is_set; });
|
|
is_set = false;
|
|
}
|
|
|
|
template <class Clock, class Duration>
|
|
bool WaitUntil(const std::chrono::time_point<Clock, Duration>& time) {
|
|
std::unique_lock lk{mutex};
|
|
if (!condvar.wait_until(lk, time, [this] { return is_set; }))
|
|
return false;
|
|
is_set = false;
|
|
return true;
|
|
}
|
|
|
|
void Reset() {
|
|
std::unique_lock lk{mutex};
|
|
// no other action required, since wait loops on the predicate and any lingering signal will
|
|
// get cleared on the first iteration
|
|
is_set = false;
|
|
}
|
|
|
|
private:
|
|
bool is_set = false;
|
|
std::condition_variable condvar;
|
|
std::mutex mutex;
|
|
};
|
|
|
|
class Barrier {
|
|
public:
|
|
explicit Barrier(std::size_t count_) : count(count_) {}
|
|
|
|
/// Blocks until all "count" threads have called Sync()
|
|
void Sync() {
|
|
std::unique_lock lk{mutex};
|
|
const std::size_t current_generation = generation;
|
|
|
|
if (++waiting == count) {
|
|
generation++;
|
|
waiting = 0;
|
|
condvar.notify_all();
|
|
} else {
|
|
condvar.wait(lk,
|
|
[this, current_generation] { return current_generation != generation; });
|
|
}
|
|
}
|
|
|
|
private:
|
|
std::condition_variable condvar;
|
|
std::mutex mutex;
|
|
std::size_t count;
|
|
std::size_t waiting = 0;
|
|
std::size_t generation = 0; // Incremented once each time the barrier is used
|
|
};
|
|
|
|
void SetCurrentThreadName(const char* name);
|
|
|
|
} // namespace Common
|