Relintai/pandemonium_engine
1
0
Fork 0
mirror of https://github.com/Relintai/pandemonium_engine.git synced 2025-01-11 21:31:10 +01:00
Code Issues Packages Projects Releases Wiki Activity

Added the rest of the new container classes from godot4. They will likely not work as-is, this will be fixed later.

Browse Source
This commit is contained in:
Relintai 2023-01-16 00:40:55 +01:00
parent 3c461a4660
commit b6f4b647d6
5 changed files with 984 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

181
core/containers/bin_sorted_array.h Normal file
View File

@ -0,0 +1,181 @@
/**************************************************************************/
/* bin_sorted_array.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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. */
/**************************************************************************/
#ifndef BIN_SORTED_ARRAY_H
#define BIN_SORTED_ARRAY_H
#include "core/templates/local_vector.h"
#include "core/templates/paged_array.h"
template <class T>
class BinSortedArray {
PagedArray<T> array;
LocalVector<uint64_t> bin_limits;
// Implement if elements need to keep track of their own index in the array.
_FORCE_INLINE_ virtual void _update_idx(T &r_element, uint64_t p_idx) {}
_FORCE_INLINE_ void _swap(uint64_t p_a, uint64_t p_b) {
SWAP(array[p_a], array[p_b]);
_update_idx(array[p_a], p_a);
_update_idx(array[p_b], p_b);
}
public:
uint64_t insert(T &p_element, uint64_t p_bin) {
array.push_back(p_element);
uint64_t new_idx = array.size() - 1;
_update_idx(p_element, new_idx);
bin_limits[0] = new_idx;
if (p_bin != 0) {
new_idx = move(new_idx, p_bin);
}
return new_idx;
}
uint64_t move(uint64_t p_idx, uint64_t p_bin) {
ERR_FAIL_UNSIGNED_INDEX_V(p_idx, array.size(), -1);
uint64_t current_bin = bin_limits.size() - 1;
while (p_idx > bin_limits[current_bin]) {
current_bin--;
}
if (p_bin == current_bin) {
return p_idx;
}
uint64_t current_idx = p_idx;
if (p_bin > current_bin) {
while (p_bin > current_bin) {
uint64_t swap_idx = 0;
if (current_bin == bin_limits.size() - 1) {
bin_limits.push_back(0);
} else {
bin_limits[current_bin + 1]++;
swap_idx = bin_limits[current_bin + 1];
}
if (current_idx != swap_idx) {
_swap(current_idx, swap_idx);
current_idx = swap_idx;
}
current_bin++;
}
} else {
while (p_bin < current_bin) {
uint64_t swap_idx = bin_limits[current_bin];
if (current_idx != swap_idx) {
_swap(current_idx, swap_idx);
}
if (current_bin == bin_limits.size() - 1 && bin_limits[current_bin] == 0) {
bin_limits.resize(bin_limits.size() - 1);
} else {
bin_limits[current_bin]--;
}
current_idx = swap_idx;
current_bin--;
}
}
return current_idx;
}
void remove_at(uint64_t p_idx) {
ERR_FAIL_UNSIGNED_INDEX(p_idx, array.size());
uint64_t new_idx = move(p_idx, 0);
uint64_t swap_idx = array.size() - 1;
if (new_idx != swap_idx) {
_swap(new_idx, swap_idx);
}
if (bin_limits[0] > 0) {
bin_limits[0]--;
}
array.pop_back();
}
void set_page_pool(PagedArrayPool<T> *p_page_pool) {
array.set_page_pool(p_page_pool);
}
_FORCE_INLINE_ const T &operator[](uint64_t p_index) const {
return array[p_index];
}
_FORCE_INLINE_ T &operator[](uint64_t p_index) {
return array[p_index];
}
int get_bin_count() {
if (array.size() == 0) {
return 0;
}
return bin_limits.size();
}
int get_bin_start(int p_bin) {
ERR_FAIL_COND_V(p_bin >= get_bin_count(), ~0U);
if ((unsigned int)p_bin == bin_limits.size() - 1) {
return 0;
}
return bin_limits[p_bin + 1] + 1;
}
int get_bin_size(int p_bin) {
ERR_FAIL_COND_V(p_bin >= get_bin_count(), 0);
if ((unsigned int)p_bin == bin_limits.size() - 1) {
return bin_limits[p_bin] + 1;
}
return bin_limits[p_bin] - bin_limits[p_bin + 1];
}
void reset() {
array.reset();
bin_limits.clear();
bin_limits.push_back(0);
}
BinSortedArray() {
bin_limits.push_back(0);
}
virtual ~BinSortedArray() {
reset();
}
};
#endif // BIN_SORTED_ARRAY_H

127
core/containers/lru.h Normal file
View File

@ -0,0 +1,127 @@
/**************************************************************************/
/* lru.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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. */
/**************************************************************************/
#ifndef LRU_H
#define LRU_H
#include "core/math/math_funcs.h"
#include "hash_map.h"
#include "list.h"
template <class TKey, class TData, class Hasher = HashMapHasherDefault, class Comparator = HashMapComparatorDefault<TKey>>
class LRUCache {
private:
struct Pair {
TKey key;
TData data;
Pair() {}
Pair(const TKey &p_key, const TData &p_data) :
key(p_key),
data(p_data) {
}
};
typedef typename List<Pair>::Element *Element;
List<Pair> _list;
HashMap<TKey, Element, Hasher, Comparator> _map;
size_t capacity;
public:
const TData *insert(const TKey &p_key, const TData &p_value) {
Element *e = _map.getptr(p_key);
Element n = _list.push_front(Pair(p_key, p_value));
if (e) {
_list.erase(*e);
_map.erase(p_key);
}
_map[p_key] = _list.front();
while (_map.size() > capacity) {
Element d = _list.back();
_map.erase(d->get().key);
_list.pop_back();
}
return &n->get().data;
}
void clear() {
_map.clear();
_list.clear();
}
bool has(const TKey &p_key) const {
return _map.getptr(p_key);
}
const TData &get(const TKey &p_key) {
Element *e = _map.getptr(p_key);
CRASH_COND(!e);
_list.move_to_front(*e);
return (*e)->get().data;
};
const TData *getptr(const TKey &p_key) {
Element *e = _map.getptr(p_key);
if (!e) {
return nullptr;
} else {
_list.move_to_front(*e);
return &(*e)->get().data;
}
}
_FORCE_INLINE_ size_t get_capacity() const { return capacity; }
_FORCE_INLINE_ size_t get_size() const { return _map.size(); }
void set_capacity(size_t p_capacity) {
if (capacity > 0) {
capacity = p_capacity;
while (_map.size() > capacity) {
Element d = _list.back();
_map.erase(d->get().key);
_list.pop_back();
}
}
}
LRUCache() {
capacity = 64;
}
LRUCache(int p_capacity) {
capacity = p_capacity;
}
};
#endif // LRU_H

369
core/containers/paged_array.h Normal file
View File

@ -0,0 +1,369 @@
/**************************************************************************/
/* paged_array.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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. */
/**************************************************************************/
#ifndef PAGED_ARRAY_H
#define PAGED_ARRAY_H
#include "core/os/memory.h"
#include "core/os/spin_lock.h"
#include "core/typedefs.h"
#include <type_traits>
// PagedArray is used mainly for filling a very large array from multiple threads efficiently and without causing major fragmentation
// PageArrayPool manages central page allocation in a thread safe matter
template <class T>
class PagedArrayPool {
T **page_pool = nullptr;
uint32_t pages_allocated = 0;
uint32_t *available_page_pool = nullptr;
uint32_t pages_available = 0;
uint32_t page_size = 0;
SpinLock spin_lock;
public:
uint32_t alloc_page() {
spin_lock.lock();
if (unlikely(pages_available == 0)) {
uint32_t pages_used = pages_allocated;
pages_allocated++;
page_pool = (T **)memrealloc(page_pool, sizeof(T *) * pages_allocated);
available_page_pool = (uint32_t *)memrealloc(available_page_pool, sizeof(uint32_t) * pages_allocated);
page_pool[pages_used] = (T *)memalloc(sizeof(T) * page_size);
available_page_pool[0] = pages_used;
pages_available++;
}
pages_available--;
uint32_t page = available_page_pool[pages_available];
spin_lock.unlock();
return page;
}
T *get_page(uint32_t p_page_id) {
return page_pool[p_page_id];
}
void free_page(uint32_t p_page_id) {
spin_lock.lock();
available_page_pool[pages_available] = p_page_id;
pages_available++;
spin_lock.unlock();
}
uint32_t get_page_size_shift() const {
return get_shift_from_power_of_2(page_size);
}
uint32_t get_page_size_mask() const {
return page_size - 1;
}
void reset() {
ERR_FAIL_COND(pages_available < pages_allocated);
if (pages_allocated) {
for (uint32_t i = 0; i < pages_allocated; i++) {
memfree(page_pool[i]);
}
memfree(page_pool);
memfree(available_page_pool);
page_pool = nullptr;
available_page_pool = nullptr;
pages_allocated = 0;
pages_available = 0;
}
}
bool is_configured() const {
return page_size > 0;
}
void configure(uint32_t p_page_size) {
ERR_FAIL_COND(page_pool != nullptr); //sanity check
ERR_FAIL_COND(p_page_size == 0);
page_size = nearest_power_of_2_templated(p_page_size);
}
PagedArrayPool(uint32_t p_page_size = 4096) { // power of 2 recommended because of alignment with OS page sizes. Even if element is bigger, its still a multiple and get rounded amount of pages
configure(p_page_size);
}
~PagedArrayPool() {
ERR_FAIL_COND_MSG(pages_available < pages_allocated, "Pages in use exist at exit in PagedArrayPool");
reset();
}
};
// PageArray is a local array that is optimized to grow in place, then be cleared often.
// It does so by allocating pages from a PagedArrayPool.
// It is safe to use multiple PagedArrays from different threads, sharing a single PagedArrayPool
template <class T>
class PagedArray {
PagedArrayPool<T> *page_pool = nullptr;
T **page_data = nullptr;
uint32_t *page_ids = nullptr;
uint32_t max_pages_used = 0;
uint32_t page_size_shift = 0;
uint32_t page_size_mask = 0;
uint64_t count = 0;
_FORCE_INLINE_ uint32_t _get_pages_in_use() const {
if (count == 0) {
return 0;
} else {
return ((count - 1) >> page_size_shift) + 1;
}
}
void _grow_page_array() {
//no more room in the page array to put the new page, make room
if (max_pages_used == 0) {
max_pages_used = 1;
} else {
max_pages_used *= 2; // increase in powers of 2 to keep allocations to minimum
}
page_data = (T **)memrealloc(page_data, sizeof(T *) * max_pages_used);
page_ids = (uint32_t *)memrealloc(page_ids, sizeof(uint32_t) * max_pages_used);
}
public:
_FORCE_INLINE_ const T &operator[](uint64_t p_index) const {
CRASH_BAD_UNSIGNED_INDEX(p_index, count);
uint32_t page = p_index >> page_size_shift;
uint32_t offset = p_index & page_size_mask;
return page_data[page][offset];
}
_FORCE_INLINE_ T &operator[](uint64_t p_index) {
CRASH_BAD_UNSIGNED_INDEX(p_index, count);
uint32_t page = p_index >> page_size_shift;
uint32_t offset = p_index & page_size_mask;
return page_data[page][offset];
}
_FORCE_INLINE_ void push_back(const T &p_value) {
uint32_t remainder = count & page_size_mask;
if (unlikely(remainder == 0)) {
// at 0, so time to request a new page
uint32_t page_count = _get_pages_in_use();
uint32_t new_page_count = page_count + 1;
if (unlikely(new_page_count > max_pages_used)) {
ERR_FAIL_COND(page_pool == nullptr); //sanity check
_grow_page_array(); //keep out of inline
}
uint32_t page_id = page_pool->alloc_page();
page_data[page_count] = page_pool->get_page(page_id);
page_ids[page_count] = page_id;
}
// place the new value
uint32_t page = count >> page_size_shift;
uint32_t offset = count & page_size_mask;
if (!std::is_trivially_constructible<T>::value) {
memnew_placement(&page_data[page][offset], T(p_value));
} else {
page_data[page][offset] = p_value;
}
count++;
}
_FORCE_INLINE_ void pop_back() {
ERR_FAIL_COND(count == 0);
if (!std::is_trivially_destructible<T>::value) {
uint32_t page = (count - 1) >> page_size_shift;
uint32_t offset = (count - 1) & page_size_mask;
page_data[page][offset].~T();
}
uint32_t remainder = count & page_size_mask;
if (unlikely(remainder == 1)) {
// one element remained, so page must be freed.
uint32_t last_page = _get_pages_in_use() - 1;
page_pool->free_page(page_ids[last_page]);
}
count--;
}
void clear() {
//destruct if needed
if (!std::is_trivially_destructible<T>::value) {
for (uint64_t i = 0; i < count; i++) {
uint32_t page = i >> page_size_shift;
uint32_t offset = i & page_size_mask;
page_data[page][offset].~T();
}
}
//return the pages to the pagepool, so they can be used by another array eventually
uint32_t pages_used = _get_pages_in_use();
for (uint32_t i = 0; i < pages_used; i++) {
page_pool->free_page(page_ids[i]);
}
count = 0;
//note we leave page_data and page_indices intact for next use. If you really want to clear them call reset()
}
void reset() {
clear();
if (page_data) {
memfree(page_data);
memfree(page_ids);
page_data = nullptr;
page_ids = nullptr;
max_pages_used = 0;
}
}
// This takes the pages from a source array and merges them to this one
// resulting order is undefined, but content is merged very efficiently,
// making it ideal to fill content on several threads to later join it.
void merge_unordered(PagedArray<T> &p_array) {
ERR_FAIL_COND(page_pool != p_array.page_pool);
uint32_t remainder = count & page_size_mask;
T *remainder_page = nullptr;
uint32_t remainder_page_id = 0;
if (remainder > 0) {
uint32_t last_page = _get_pages_in_use() - 1;
remainder_page = page_data[last_page];
remainder_page_id = page_ids[last_page];
}
count -= remainder;
uint32_t src_pages = p_array._get_pages_in_use();
uint32_t page_size = page_size_mask + 1;
for (uint32_t i = 0; i < src_pages; i++) {
uint32_t page_count = _get_pages_in_use();
uint32_t new_page_count = page_count + 1;
if (unlikely(new_page_count > max_pages_used)) {
_grow_page_array(); //keep out of inline
}
page_data[page_count] = p_array.page_data[i];
page_ids[page_count] = p_array.page_ids[i];
if (i == src_pages - 1) {
//last page, only increment with remainder
count += p_array.count & page_size_mask;
} else {
count += page_size;
}
}
p_array.count = 0; //take away the other array pages
//handle the remainder page if exists
if (remainder_page) {
uint32_t new_remainder = count & page_size_mask;
if (new_remainder > 0) {
//must merge old remainder with new remainder
T *dst_page = page_data[_get_pages_in_use() - 1];
uint32_t to_copy = MIN(page_size - new_remainder, remainder);
for (uint32_t i = 0; i < to_copy; i++) {
if (!std::is_trivially_constructible<T>::value) {
memnew_placement(&dst_page[i + new_remainder], T(remainder_page[i + remainder - to_copy]));
} else {
dst_page[i + new_remainder] = remainder_page[i + remainder - to_copy];
}
if (!std::is_trivially_destructible<T>::value) {
remainder_page[i + remainder - to_copy].~T();
}
}
remainder -= to_copy; //subtract what was copied from remainder
count += to_copy; //add what was copied to the count
if (remainder == 0) {
//entire remainder copied, let go of remainder page
page_pool->free_page(remainder_page_id);
remainder_page = nullptr;
}
}
if (remainder > 0) {
//there is still remainder, append it
uint32_t page_count = _get_pages_in_use();
uint32_t new_page_count = page_count + 1;
if (unlikely(new_page_count > max_pages_used)) {
_grow_page_array(); //keep out of inline
}
page_data[page_count] = remainder_page;
page_ids[page_count] = remainder_page_id;
count += remainder;
}
}
}
_FORCE_INLINE_ uint64_t size() const {
return count;
}
void set_page_pool(PagedArrayPool<T> *p_page_pool) {
ERR_FAIL_COND(max_pages_used > 0); //sanity check
page_pool = p_page_pool;
page_size_mask = page_pool->get_page_size_mask();
page_size_shift = page_pool->get_page_size_shift();
}
~PagedArray() {
reset();
}
};
#endif // PAGED_ARRAY_H

240
core/containers/safe_list.h Normal file
View File

@ -0,0 +1,240 @@
/**************************************************************************/
/* safe_list.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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. */
/**************************************************************************/
#ifndef SAFE_LIST_H
#define SAFE_LIST_H
#include "core/os/memory.h"
#include "core/typedefs.h"
#include <atomic>
#include <functional>
#include <type_traits>
// Design goals for these classes:
// - Accessing this list with an iterator will never result in a use-after free,
// even if the element being accessed has been logically removed from the list on
// another thread.
// - Logical deletion from the list will not result in deallocation at that time,
// instead the node will be deallocated at a later time when it is safe to do so.
// - No blocking synchronization primitives will be used.
// This is used in very specific areas of the engine where it's critical that these guarantees are held.
template <class T, class A = DefaultAllocator>
class SafeList {
struct SafeListNode {
std::atomic<SafeListNode *> next = nullptr;
// If the node is logically deleted, this pointer will typically point
// to the previous list item in time that was also logically deleted.
std::atomic<SafeListNode *> graveyard_next = nullptr;
std::function<void(T)> deletion_fn = [](T t) { return; };
T val;
};
static_assert(std::atomic<T>::is_always_lock_free);
std::atomic<SafeListNode *> head = nullptr;
std::atomic<SafeListNode *> graveyard_head = nullptr;
std::atomic_uint active_iterator_count = 0;
public:
class Iterator {
friend class SafeList;
SafeListNode *cursor = nullptr;
SafeList *list = nullptr;
Iterator(SafeListNode *p_cursor, SafeList *p_list) :
cursor(p_cursor), list(p_list) {
list->active_iterator_count++;
}
public:
Iterator(const Iterator &p_other) :
cursor(p_other.cursor), list(p_other.list) {
list->active_iterator_count++;
}
~Iterator() {
list->active_iterator_count--;
}
public:
T &operator*() {
return cursor->val;
}
Iterator &operator++() {
cursor = cursor->next;
return *this;
}
// These two operators are mostly useful for comparisons to nullptr.
bool operator==(const void *p_other) const {
return cursor == p_other;
}
bool operator!=(const void *p_other) const {
return cursor != p_other;
}
// These two allow easy range-based for loops.
bool operator==(const Iterator &p_other) const {
return cursor == p_other.cursor;
}
bool operator!=(const Iterator &p_other) const {
return cursor != p_other.cursor;
}
};
public:
// Calling this will cause an allocation.
void insert(T p_value) {
SafeListNode *new_node = memnew_allocator(SafeListNode, A);
new_node->val = p_value;
SafeListNode *expected_head = nullptr;
do {
expected_head = head.load();
new_node->next.store(expected_head);
} while (!head.compare_exchange_strong(/* expected= */ expected_head, /* new= */ new_node));
}
Iterator find(T p_value) {
for (Iterator it = begin(); it != end(); ++it) {
if (*it == p_value) {
return it;
}
}
return end();
}
void erase(T p_value, std::function<void(T)> p_deletion_fn) {
Iterator tmp = find(p_value);
erase(tmp, p_deletion_fn);
}
void erase(T p_value) {
Iterator tmp = find(p_value);
erase(tmp, [](T t) { return; });
}
void erase(Iterator &p_iterator, std::function<void(T)> p_deletion_fn) {
p_iterator.cursor->deletion_fn = p_deletion_fn;
erase(p_iterator);
}
void erase(Iterator &p_iterator) {
if (find(p_iterator.cursor->val) == nullptr) {
// Not in the list, nothing to do.
return;
}
// First, remove the node from the list.
while (true) {
Iterator prev = begin();
SafeListNode *expected_head = prev.cursor;
for (; prev != end(); ++prev) {
if (prev.cursor && prev.cursor->next == p_iterator.cursor) {
break;
}
}
if (prev != end()) {
// There exists a node before this.
prev.cursor->next.store(p_iterator.cursor->next.load());
// Done.
break;
} else {
if (head.compare_exchange_strong(/* expected= */ expected_head, /* new= */ p_iterator.cursor->next.load())) {
// Successfully reassigned the head pointer before another thread changed it to something else.
break;
}
// Fall through upon failure, try again.
}
}
// Then queue it for deletion by putting it in the node graveyard.
// Don't touch `next` because an iterator might still be pointing at this node.
SafeListNode *expected_head = nullptr;
do {
expected_head = graveyard_head.load();
p_iterator.cursor->graveyard_next.store(expected_head);
} while (!graveyard_head.compare_exchange_strong(/* expected= */ expected_head, /* new= */ p_iterator.cursor));
}
Iterator begin() {
return Iterator(head.load(), this);
}
Iterator end() {
return Iterator(nullptr, this);
}
// Calling this will cause zero to many deallocations.
bool maybe_cleanup() {
SafeListNode *cursor = nullptr;
SafeListNode *new_graveyard_head = nullptr;
do {
// The access order here is theoretically important.
cursor = graveyard_head.load();
if (active_iterator_count.load() != 0) {
// It's not safe to clean up with an active iterator, because that iterator
// could be pointing to an element that we want to delete.
return false;
}
// Any iterator created after this point will never point to a deleted node.
// Swap it out with the current graveyard head.
} while (!graveyard_head.compare_exchange_strong(/* expected= */ cursor, /* new= */ new_graveyard_head));
// Our graveyard list is now unreachable by any active iterators,
// detached from the main graveyard head and ready for deletion.
while (cursor) {
SafeListNode *tmp = cursor;
cursor = cursor->graveyard_next;
tmp->deletion_fn(tmp->val);
memdelete_allocator<SafeListNode, A>(tmp);
}
return true;
}
~SafeList() {
#ifdef DEBUG_ENABLED
if (!maybe_cleanup()) {
ERR_PRINT("There are still iterators around when destructing a SafeList. Memory will be leaked. This is a bug.");
}
#else
maybe_cleanup();
#endif
}
};
#endif // SAFE_LIST_H

67
core/containers/search_array.h Normal file
View File

@ -0,0 +1,67 @@
/**************************************************************************/
/* search_array.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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. */
/**************************************************************************/
#ifndef SEARCH_ARRAY_H
#define SEARCH_ARRAY_H
#include <core/templates/sort_array.h>
template <class T, class Comparator = _DefaultComparator<T>>
class SearchArray {
public:
Comparator compare;
inline int bisect(const T *p_array, int p_len, const T &p_value, bool p_before) const {
int lo = 0;
int hi = p_len;
if (p_before) {
while (lo < hi) {
const int mid = (lo + hi) / 2;
if (compare(p_array[mid], p_value)) {
lo = mid + 1;
} else {
hi = mid;
}
}
} else {
while (lo < hi) {
const int mid = (lo + hi) / 2;
if (compare(p_value, p_array[mid])) {
hi = mid;
} else {
lo = mid + 1;
}
}
}
return lo;
}
};
#endif // SEARCH_ARRAY_H