mirror of
https://github.com/RPCSX/rpcsx.git
synced 2025-12-31 13:50:46 +01:00
575a245f8d
Replaces `std::shared_pointer` with `stx::atomic_ptr` and `stx::shared_ptr`. Notes to programmers: * This pr kills the use of `dynamic_cast`, `std::dynamic_pointer_cast` and `std::weak_ptr` on IDM objects, possible replacement is to save the object ID on the base object, then use idm::check/get_unlocked to the destination type via the saved ID which may be null. Null pointer check is how you can tell type mismatch (as dynamic cast) or object destruction (as weak_ptr locking). * Double-inheritance on IDM objects should be used with care, `stx::shared_ptr` does not support constant-evaluated pointer offsetting to parent/child type. * `idm::check/get_unlocked` can now be used anywhere. Misc fixes: * Fixes some segfaults with RPCN with interaction with IDM. * Fix deadlocks in access violation handler due locking recursion. * Fixes race condition in process exit-spawn on memory containers read. * Fix bug that theoretically can prevent RPCS3 from booting - fix `id_manager::typeinfo` comparison to compare members instead of `memcmp` which can fail spuriously on padding bytes. * Ensure all IDM inherited types of base, either has `id_base` or `id_type` defined locally, this allows to make getters such as `idm::get_unlocked<lv2_socket, lv2_socket_raw>()` which were broken before. (requires save-states invalidation) * Removes broken operator[] overload of `stx::shared_ptr` and `stx::single_ptr` for non-array types.
73 lines
1.5 KiB
C++
73 lines
1.5 KiB
C++
#pragma once
|
|
|
|
#include <memory>
|
|
#include <unordered_map>
|
|
|
|
#include "Utilities/mutex.h"
|
|
|
|
#include "util/shared_ptr.hpp"
|
|
|
|
// IPC manager for objects of type T and IPC keys of type K.
|
|
template <typename T, typename K>
|
|
class ipc_manager final
|
|
{
|
|
std::unordered_map<K, shared_ptr<T>> m_map;
|
|
|
|
mutable shared_mutex m_mutex;
|
|
|
|
public:
|
|
// Add new object if specified ipc_key is not used
|
|
// .first: added new object?, .second: what's at m_map[key] after this function if (peek_ptr || added new object) is true
|
|
template <typename F>
|
|
std::pair<bool, shared_ptr<T>> add(const K& ipc_key, F&& provider, bool peek_ptr = true)
|
|
{
|
|
std::lock_guard lock(m_mutex);
|
|
|
|
// Get object location
|
|
shared_ptr<T>& ptr = m_map[ipc_key];
|
|
const bool existed = ptr.operator bool();
|
|
|
|
if (!existed)
|
|
{
|
|
// Call a function which must return the object
|
|
ptr = provider();
|
|
}
|
|
|
|
const bool added = !existed && ptr;
|
|
return {added, (peek_ptr || added) ? ptr : null_ptr};
|
|
}
|
|
|
|
// Unregister specified ipc_key, may return true even if the object doesn't exist anymore
|
|
bool remove(const K& ipc_key)
|
|
{
|
|
std::lock_guard lock(m_mutex);
|
|
|
|
return m_map.erase(ipc_key) != 0;
|
|
}
|
|
|
|
// Get object with specified ipc_key
|
|
shared_ptr<T> get(const K& ipc_key) const
|
|
{
|
|
reader_lock lock(m_mutex);
|
|
|
|
const auto found = m_map.find(ipc_key);
|
|
|
|
if (found != m_map.end())
|
|
{
|
|
return found->second;
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
// Check whether the object actually exists
|
|
bool check(const K& ipc_key) const
|
|
{
|
|
reader_lock lock(m_mutex);
|
|
|
|
const auto found = m_map.find(ipc_key);
|
|
|
|
return found != m_map.end();
|
|
}
|
|
};
|