godot/core/rid_handle.cpp
lawnjelly 3d981b8265 Add option to use handles to RID
Adds an option to compile an alternative implementation for RIDs, which allows checks for erroneous usage patterns as well as providing leak tests.
2021-12-06 14:43:34 +00:00

304 lines
9.7 KiB
C++

/*************************************************************************/
/* rid_handle.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "rid_handle.h"
#ifdef RID_HANDLES_ENABLED
#include "core/os/memory.h"
#include "core/print_string.h"
#include "core/ustring.h"
// This define will flag up an error when get() or getptr() is called with a NULL object.
// These calls should more correctly be made as get_or_null().
// #define RID_HANDLE_FLAG_NULL_GETS
RID_Database g_rid_database;
RID_Data::~RID_Data() {
}
void RID_OwnerBase::init_rid() {
// NOOP
}
RID_OwnerBase::~RID_OwnerBase() {
_shutdown = true;
}
void RID_OwnerBase::_rid_print(const char *pszType, String sz, const RID &p_rid) {
String tn = pszType;
print_line(tn + " : " + sz + " " + itos(p_rid._id) + " [ " + itos(p_rid._revision) + " ]");
}
RID_Database::RID_Database() {
// request first element so the handles start from 1
uint32_t dummy;
_pool.request(dummy);
}
RID_Database::~RID_Database() {
}
String RID_Database::_rid_to_string(const RID &p_rid, const PoolElement &p_pe) {
String s = "RID id=" + itos(p_rid._id);
s += " [ rev " + itos(p_rid._revision) + " ], ";
s += "PE [ rev " + itos(p_pe.revision) + " ] ";
#ifdef RID_HANDLE_ALLOCATION_TRACKING_ENABLED
if (p_pe.filename) {
s += String(p_pe.filename) + " ";
}
s += "line " + itos(p_pe.line_number);
#endif
return s;
}
void RID_Database::preshutdown() {
#ifdef RID_HANDLE_ALLOCATION_TRACKING_ENABLED
for (uint32_t n = 0; n < _pool.active_size(); n++) {
uint32_t id = _pool.get_active_id(n);
// ignore zero as it is a dummy
if (!id) {
continue;
}
PoolElement &pe = _pool[id];
if (pe.data) {
if (pe.data->_owner) {
const char *tn = pe.data->_owner->get_typename();
// does it already exist?
bool found = false;
for (unsigned int i = 0; i < _owner_names.size(); i++) {
if (_owner_names[i] == tn) {
found = true;
pe.owner_name_id = i;
}
}
if (!found) {
pe.owner_name_id = _owner_names.size();
_owner_names.push_back(tn);
}
}
}
}
#endif
}
void RID_Database::register_leak(uint32_t p_line_number, uint32_t p_owner_name_id, const char *p_filename) {
// does the leak exist already?
for (unsigned int n = 0; n < _leaks.size(); n++) {
Leak &leak = _leaks[n];
if ((leak.line_number == p_line_number) && (leak.filename == p_filename) && (leak.owner_name_id == p_owner_name_id)) {
leak.num_objects_leaked += 1;
return;
}
}
Leak leak;
leak.filename = p_filename;
leak.line_number = p_line_number;
leak.owner_name_id = p_owner_name_id;
leak.num_objects_leaked = 1;
_leaks.push_back(leak);
}
void RID_Database::shutdown() {
// free the first dummy element, so we don't report a false leak
_pool.free(0);
// print leaks
if (_pool.active_size()) {
ERR_PRINT("RID_Database leaked " + itos(_pool.active_size()) + " objects at exit.");
#ifdef RID_HANDLE_ALLOCATION_TRACKING_ENABLED
for (uint32_t n = 0; n < _pool.active_size(); n++) {
const PoolElement &pe = _pool.get_active(n);
register_leak(pe.line_number, pe.owner_name_id, pe.filename);
}
#endif
}
#ifdef RID_HANDLE_ALLOCATION_TRACKING_ENABLED
for (uint32_t n = 0; n < _leaks.size(); n++) {
const Leak &leak = _leaks[n];
const char *tn = "RID_Owner unknown";
if (_owner_names.size()) {
tn = _owner_names[leak.owner_name_id];
}
const char *fn = "Filename unknown";
if (leak.filename) {
fn = leak.filename;
}
_err_print_error(tn, fn, leak.line_number, itos(leak.num_objects_leaked) + " RID objects leaked");
}
#endif
_shutdown = true;
}
void RID_Database::handle_make_rid(RID &r_rid, RID_Data *p_data, RID_OwnerBase *p_owner) {
ERR_FAIL_COND_MSG(_shutdown, "RID_Database make_rid use after shutdown.");
ERR_FAIL_COND_MSG(!p_data, "RID_Database make_rid, data is empty.");
bool data_was_empty = true;
_mutex.lock();
PoolElement *pe = _pool.request(r_rid._id);
data_was_empty = !pe->data;
pe->data = p_data;
p_data->_owner = p_owner;
pe->revision = pe->revision + 1;
r_rid._revision = pe->revision;
#ifdef RID_HANDLE_ALLOCATION_TRACKING_ENABLED
pe->line_number = 0;
pe->filename = nullptr;
#endif
_mutex.unlock();
ERR_FAIL_COND_MSG(!data_was_empty, "RID_Database make_rid, previous data was not empty.");
}
RID_Data *RID_Database::handle_get(const RID &p_rid) {
RID_Data *data = handle_get_or_null(p_rid);
#ifdef RID_HANDLE_FLAG_NULL_GETS
ERR_FAIL_COND_V_MSG(!data, nullptr, "RID_Database get is NULL");
#endif
return data;
}
RID_Data *RID_Database::handle_getptr(const RID &p_rid) {
RID_Data *data = handle_get_or_null(p_rid);
#ifdef RID_HANDLE_FLAG_NULL_GETS
ERR_FAIL_COND_V_MSG(!data, nullptr, "RID_Database getptr is NULL");
#endif
return data;
}
// Note, no locks used in the getters.
// Godot 4.x does use locks in the getters, but it is arguably overkill because even though
// the pointer returned will be correct (i.e. it has not been replaced during this call),
// it can be invalidated during the client code use. (There may also be an internal reason why
// locks are needed in 4.x, as the database is different.)
// An example of a "safer" way to do this kind of thing is object level locking,
// (but that has complications of its own), or atomic object changes.
RID_Data *RID_Database::handle_get_or_null(const RID &p_rid) {
if (p_rid.is_valid()) {
ERR_FAIL_COND_V_MSG(_shutdown, nullptr, "RID_Database get_or_null after shutdown.");
// The if statement is to allow breakpointing without a recompile.
if (p_rid._id >= _pool.pool_reserved_size()) {
ERR_FAIL_COND_V_MSG(p_rid._id >= _pool.pool_reserved_size(), nullptr, "RID_Database get_or_null, RID id was outside pool size.");
}
const PoolElement &pe = _pool[p_rid._id];
if (pe.revision != p_rid._revision) {
print_verbose("RID revision incorrect : " + _rid_to_string(p_rid, pe));
ERR_FAIL_COND_V_MSG(pe.revision != p_rid._revision, nullptr, "RID_Database get_or_null, revision is incorrect, object possibly freed before use.");
}
return pe.data;
}
return nullptr;
}
bool RID_Database::handle_owns(const RID &p_rid) const {
ERR_FAIL_COND_V_MSG(_shutdown, false, "RID_Database owns after shutdown.");
if (!p_rid.is_valid()) {
return false;
}
if (p_rid._id >= _pool.pool_reserved_size()) {
return false;
}
const PoolElement &pe = _pool[p_rid._id];
if (pe.revision != p_rid._revision) {
return false;
}
if (!pe.data) {
return false;
}
return true;
}
void RID_Database::handle_free(const RID &p_rid) {
ERR_FAIL_COND_MSG(_shutdown, "RID_Database free after shutdown.");
bool revision_correct = true;
ERR_FAIL_COND_MSG(p_rid._id >= _pool.pool_reserved_size(), "RID_Database free, RID id was outside pool size.");
_mutex.lock();
PoolElement &pe = _pool[p_rid._id];
revision_correct = pe.revision == p_rid._revision;
// mark the data as zero, which indicates unused element
if (revision_correct) {
pe.data->_owner = nullptr;
pe.data = nullptr;
_pool.free(p_rid._id);
}
_mutex.unlock();
ERR_FAIL_COND_MSG(!revision_correct, "RID_Database free, revision is incorrect, object possibly freed more than once.");
}
RID RID_Database::prime(const RID &p_rid, int p_line_number, const char *p_filename) {
#ifdef RID_HANDLE_ALLOCATION_TRACKING_ENABLED
if (p_rid.is_valid()) {
ERR_FAIL_COND_V_MSG(_shutdown, p_rid, "RID_Database prime after shutdown.");
ERR_FAIL_COND_V_MSG(p_rid._id >= _pool.pool_reserved_size(), p_rid, "RID_Database prime, RID id was outside pool size.");
PoolElement &pe = _pool[p_rid._id];
ERR_FAIL_COND_V_MSG(pe.revision != p_rid._revision, p_rid, "RID_Database prime, revision is incorrect, object possibly freed before use.");
// no threading checks as it the tracking info doesn't matter if there is a race condition
pe.line_number = p_line_number;
pe.filename = p_filename;
}
#endif
return p_rid;
}
#endif // RID_HANDLES_ENABLED