mirror of
https://github.com/hrydgard/ppsspp.git
synced 2026-10-16 07:50:28 +02:00
libretroadmin
f1208a7a5a
The core and the headless tools no longer use mutexes, condition variables, spinlocks, std::atomic, std::thread or volatile flags. Threads hand off through libretro-common's retro_atomic and rthreads plus a few small pieces on top of them in Common/Thread: Thread, MpscQueue, EventCounter, ParkingLot waits and ReaderGate. Every wait blocks until it's woken; nothing polls on a timer. State that only one thread touches just loses its lock. The PSP filesystem, sceIo and the savedata dialog now belong to the emulation thread: async reads and writes run when they're queued and complete later in emulated time, and the IO and savedata threads are gone. The friend finder only talks to the adhoc server and hands what it gets to the emulation thread. GPU init always runs on the thread that starts the game. The Vulkan render and compile queues, pipeline and render pass caches, delete list and SPIR-V cache, the GL render queue, the software renderer's jit caches, the file loader caches, the web debugger, UPnP, input, savestates, logging and the GE debugger all hand off through queues and atomics. The IR jit's spinning profiler thread goes. A CPU thread with nothing to run now sleeps until work is queued instead of spinning. Headless with --debugger waits for a client while stopped, and ends the run once every client that connected has left. Web server shutdown keeps servicing the CPU queue until the server has finished.
62 lines
2.0 KiB
C++
62 lines
2.0 KiB
C++
#pragma once
|
|
|
|
#include <cstdint>
|
|
|
|
#include <retro_atomic.h>
|
|
|
|
namespace net {
|
|
|
|
// A socket that another thread can make readable, to wake a select() that
|
|
// includes it. It is a loopback UDP socket connected to itself. If one can't
|
|
// be made, Fd() is -1 and waits only see a wake when they return anyway.
|
|
class WakeSocket {
|
|
public:
|
|
WakeSocket();
|
|
~WakeSocket();
|
|
WakeSocket(const WakeSocket &) = delete;
|
|
WakeSocket &operator=(const WakeSocket &) = delete;
|
|
|
|
// Any thread. Wakes stack up into one readable state until drained.
|
|
void Wake();
|
|
// Called by the waiting thread after it wakes, before it looks at its state.
|
|
void Drain();
|
|
intptr_t Fd() const { return fd_; }
|
|
|
|
private:
|
|
intptr_t fd_ = -1;
|
|
};
|
|
|
|
// A cancel flag that socket waits block on. Cancel() sets the flag and
|
|
// wakes its socket for good, so every wait that includes it returns at once.
|
|
class CancelToken {
|
|
public:
|
|
// Any thread.
|
|
void Cancel();
|
|
bool IsCancelled() const { return retro_atomic_load_acquire_int(const_cast<retro_atomic_int_t *>(&cancelled_)) != 0; }
|
|
intptr_t WakeFd() const { return wake_.Fd(); }
|
|
|
|
private:
|
|
retro_atomic_int_t cancelled_{ 0 };
|
|
WakeSocket wake_;
|
|
};
|
|
|
|
enum class WaitResult {
|
|
READY,
|
|
TIMEOUT,
|
|
CANCELLED, // or, for the WakeSocket form, woken
|
|
FAILED,
|
|
};
|
|
|
|
// Blocks until sock is readable (or writable), cancel is set, or timeout
|
|
// seconds pass. A negative timeout waits for the first two only.
|
|
WaitResult WaitSocket(uintptr_t sock, bool forWrite, double timeout, const CancelToken *cancel);
|
|
|
|
// The same over several sockets. ready[i] says which ones are ready on READY.
|
|
WaitResult WaitSockets(const uintptr_t *socks, bool *ready, int count, bool forWrite, double timeout, const CancelToken *cancel);
|
|
|
|
// For event loops: also returns CANCELLED when wake is woken. Any of socks
|
|
// may be -1 (skipped); count may be 0, to wait only for a wake or the timeout.
|
|
WaitResult WaitSocketsOrWake(const uintptr_t *socks, bool *ready, int count, bool forWrite, double timeout, WakeSocket *wake);
|
|
|
|
} // namespace net
|