Dynamitos/Seele
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Something causing an infinite recursion...

Browse Source
This commit is contained in:
Dynamitos
2021-11-08 15:39:46 +01:00
parent 97dcf25a59
commit 6708b08d23
2 changed files with 156 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Engine/Containers/Map.h
+155 -144
View File
@@ -36,13 +36,11 @@ struct Map
private: private:
struct Node struct Node
{ {
size_t self;
size_t leftChild; size_t leftChild;
size_t rightChild; size_t rightChild;
Pair<K, V> pair; Pair<K, V> pair;
Node() Node()
: self(-1) : leftChild(-1)
, leftChild(-1)
, rightChild(-1) , rightChild(-1)
, pair() , pair()
{ {
@@ -51,9 +49,8 @@ private:
Node(Node&& other) = default; Node(Node&& other) = default;
Node& operator=(const Node& other) = default; Node& operator=(const Node& other) = default;
Node& operator=(Node&& other) = default; Node& operator=(Node&& other) = default;
Node(size_t self, K key) Node(K key)
: self(self) : leftChild(-1)
, leftChild(-1)
, rightChild(-1) , rightChild(-1)
, pair(std::move(key)) , pair(std::move(key))
{ {
@@ -74,27 +71,28 @@ public:
using reference = PairType&; using reference = PairType&;
using pointer = PairType*; using pointer = PairType*;
IteratorBase(Node *x = nullptr) IteratorBase(size_t x = -1)
: node(x) : node(x)
{ {
} }
IteratorBase(Node *x, Array<size_t> &&beginIt, const Array<Node, NodeAlloc>* nodeContainer) IteratorBase(size_t x, const Array<Node, NodeAlloc>* nodeContainer, Array<size_t> &&beginIt = Array<size_t>())
: node(x), traversal(std::move(beginIt)), nodeContainer(nodeContainer) : node(x), traversal(std::move(beginIt)), nodeContainer(nodeContainer)
{ {
} }
IteratorBase(const IteratorBase &i) IteratorBase(const IteratorBase &i)
: node(i.node), traversal(i.traversal) : node(i.node), traversal(i.traversal), nodeContainer(i.nodeContainer)
{ {
} }
IteratorBase(IteratorBase&& i) IteratorBase(IteratorBase&& i)
: node(std::move(i.node)), traversal(std::move(i.traversal)) : node(std::move(i.node)), traversal(std::move(i.traversal)), nodeContainer(i.nodeContainer)
{ {
} }
IteratorBase& operator=(const IteratorBase& other) IteratorBase& operator=(const IteratorBase& other)
{ {
if(this != &other) if(this != &other)
{ {
node = other.node; // No copy, since no ownership node = other.node;
nodeContainer = other.nodeContainer;
traversal = other.traversal; traversal = other.traversal;
} }
return *this; return *this;
@@ -104,17 +102,18 @@ public:
if(this != &other) if(this != &other)
{ {
node = std::move(other.node); node = std::move(other.node);
nodeContainer = std::move(other.nodeContainer);
traversal = std::move(other.traversal); traversal = std::move(other.traversal);
} }
return *this; return *this;
} }
reference operator*() const reference operator*() const
{ {
return node->pair; return getNode()->pair;
} }
pointer operator->() const pointer operator->() const
{ {
return &node->pair; return &(getNode()->pair);
} }
inline bool operator!=(const IteratorBase &other) inline bool operator!=(const IteratorBase &other)
{ {
@@ -126,34 +125,36 @@ public:
} }
IteratorBase &operator++() IteratorBase &operator++()
{ {
size_t nextIndex = node->rightChild; node = getNode()->rightChild;
while (nextIndex != -1 && (*nodeContainer)[nextIndex].leftChild != -1) while (node < nodeContainer->size()
&& getNode()->leftChild < nodeContainer->size())
{ {
traversal.add(nextIndex); traversal.add(node);
nextIndex = (*nodeContainer)[nextIndex].leftChild; node = getNode()->leftChild;
} }
if (nextIndex == -1 && traversal.size() > 0) if (node >= nodeContainer->size()
&& traversal.size() > 0)
{ {
nextIndex = traversal.back(); node = traversal.back();
traversal.pop(); traversal.pop();
} }
node = nextIndex != -1 ? &(*nodeContainer)[nextIndex] : nullptr;
return *this; return *this;
} }
IteratorBase &operator--() IteratorBase &operator--()
{ {
size_t nextIndex = node->leftChild; node = getNode()->leftChild;
while (nextIndex != -1 && (*nodeContainer)[nextIndex].rightChild != -1) while (node < nodeContainer->size()
&& getNode()->rightChild < nodeContainer->size())
{ {
traversal.add(nextIndex); traversal.add(node);
nextIndex = (*nodeContainer)[nextIndex].rightchild; node = getNode()->rightchild;
} }
if (nextIndex == -1 && traversal.size() > 0) if (node >= nodeContainer->size()
&& traversal.size() > 0)
{ {
nextIndex = traversal.back(); node = traversal.back();
traversal.pop(); traversal.pop();
} }
node = nextIndex != -1 ? &(*nodeContainer)[nextIndex] : nullptr;
return *this; return *this;
} }
IteratorBase operator--(int) IteratorBase operator--(int)
@@ -170,7 +171,11 @@ public:
} }
private: private:
Node *node; Node* getNode() const
{
return &(*nodeContainer)[node];
}
size_t node;
Array<size_t> traversal; Array<size_t> traversal;
const Array<Node, NodeAlloc>* nodeContainer; const Array<Node, NodeAlloc>* nodeContainer;
}; };
@@ -194,9 +199,9 @@ public:
using const_reverse_iterator = std::reverse_iterator<const_iterator>; using const_reverse_iterator = std::reverse_iterator<const_iterator>;
Map() Map()
: root(nullptr) : root(-1)
, beginIt(nullptr) , beginIt(-1)
, endIt(nullptr) , endIt(-1)
, iteratorsDirty(true) , iteratorsDirty(true)
, _size(0) , _size(0)
, comp(Compare()) , comp(Compare())
@@ -205,9 +210,9 @@ public:
explicit Map(const Compare& comp, explicit Map(const Compare& comp,
const Allocator& alloc = Allocator()) const Allocator& alloc = Allocator())
: nodeContainer(alloc) : nodeContainer(alloc)
, root(nullptr) , root(-1)
, beginIt(nullptr) , beginIt(-1)
, endIt(nullptr) , endIt(-1)
, iteratorsDirty(true) , iteratorsDirty(true)
, _size(0) , _size(0)
, comp(comp) , comp(comp)
@@ -215,9 +220,9 @@ public:
} }
explicit Map(const Allocator& alloc) explicit Map(const Allocator& alloc)
: nodeContainer(alloc) : nodeContainer(alloc)
, root(nullptr) , root(-1)
, beginIt(nullptr) , beginIt(-1)
, endIt(nullptr) , endIt(-1)
, iteratorsDirty(true) , iteratorsDirty(true)
, _size(0) , _size(0)
, comp(Compare()) , comp(Compare())
@@ -225,18 +230,18 @@ public:
} }
Map(const Map& other) Map(const Map& other)
: nodeContainer(other.nodeContainer) : nodeContainer(other.nodeContainer)
, root(other.root)
, _size(other._size) , _size(other._size)
, comp(other.comp) , comp(other.comp)
{ {
root = &nodeContainer[nodeContainer.indexOf(other.root)];
markIteratorDirty(); markIteratorDirty();
} }
Map(Map&& other) Map(Map&& other)
: nodeContainer(other.nodeContainer) : nodeContainer(other.nodeContainer)
, root(std::move(other.root))
, _size(std::move(other._size)) , _size(std::move(other._size))
, comp(std::move(other.comp)) , comp(std::move(other.comp))
{ {
root = &nodeContainer[nodeContainer.indexOf(other.root)];
markIteratorDirty(); markIteratorDirty();
} }
~Map() ~Map()
@@ -247,7 +252,7 @@ public:
if(this != &other) if(this != &other)
{ {
nodeContainer = other.nodeContainer; nodeContainer = other.nodeContainer;
root = &nodeContainer[nodeContainer.indexOf(other.root)]; root = other.root;
_size = other._size; _size = other._size;
comp = other.comp; comp = other.comp;
markIteratorDirty(); markIteratorDirty();
@@ -259,7 +264,7 @@ public:
if(this != &other) if(this != &other)
{ {
nodeContainer = std::move(other.nodeContainer); nodeContainer = std::move(other.nodeContainer);
root = &nodeContainer[nodeContainer.indexOf(other.root)]; root = std::move(other.root);
_size = std::move(other._size); _size = std::move(other._size);
comp = std::move(other.comp); comp = std::move(other.comp);
markIteratorDirty(); markIteratorDirty();
@@ -270,60 +275,68 @@ public:
{ {
root = splay(root, key); root = splay(root, key);
markIteratorDirty(); markIteratorDirty();
if (root == nullptr || comp(root->pair.key, key) || comp(key, root->pair.key)) if (root >= nodeContainer.size()
|| comp(getNode(root)->pair.key, key)
|| comp(key, getNode(root)->pair.key))
{ {
root = insert(root, key); root = insert(root, key);
_size++; _size++;
} }
return root->pair.value; return getNode(root)->pair.value;
} }
inline mapped_type& operator[](key_type&& key) inline mapped_type& operator[](key_type&& key)
{ {
root = splay(root, std::move(key)); root = splay(root, std::move(key));
markIteratorDirty(); markIteratorDirty();
if (root == nullptr || comp(root->pair.key, key) || comp(key, root->pair.key)) if (root >= nodeContainer.size()
|| comp(getNode(root)->pair.key, key)
|| comp(key, getNode(root)->pair.key))
{ {
root = insert(root, std::move(key)); root = insert(root, std::move(key));
_size++; _size++;
} }
return root->pair.value; return getNode(root)->pair.value;
} }
iterator find(const key_type& key) iterator find(const key_type& key)
{ {
root = splay(root, key); root = splay(root, key);
refreshIterators(); refreshIterators();
if (root == nullptr || comp(root->pair.key, key) || comp(key, root->pair.key)) if (!isValid(root)
|| comp(getNode(root)->pair.key, key)
|| comp(key, getNode(root)->pair.key))
{ {
return endIt; return endIt;
} }
return iterator(root); return iterator(root, &nodeContainer);
} }
iterator find(key_type&& key) iterator find(key_type&& key)
{ {
root = splay(root, std::move(key)); root = splay(root, std::move(key));
refreshIterators(); refreshIterators();
if (root == nullptr || comp(root->pair.key, key) || comp(key, root->pair.key)) if (!isValid(root)
|| comp(getNode(root)->pair.key, key)
|| comp(key, getNode(root)->pair.key))
{ {
return endIt; return endIt;
} }
return iterator(root); return iterator(root, &nodeContainer);
} }
iterator erase(const key_type& key) iterator erase(const key_type& key)
{ {
root = remove(root, key); root = remove(root, key);
refreshIterators(); refreshIterators();
return iterator(root); return iterator(root, &nodeContainer);
} }
iterator erase(K&& key) iterator erase(K&& key)
{ {
root = remove(root, std::move(key)); root = remove(root, std::move(key));
refreshIterators(); refreshIterators();
return iterator(root); return iterator(root, &nodeContainer);
} }
void clear() void clear()
{ {
nodeContainer.clear(); nodeContainer.clear();
root = nullptr; root = -1;
_size = 0; _size = 0;
markIteratorDirty(); markIteratorDirty();
} }
@@ -373,25 +386,14 @@ public:
} }
private: private:
Node* leftChild(Node* node) Node* getNode(size_t index) const
{ {
if(node->leftChild >= nodeContainer.size()) return nullptr; if(!isValid(index)) return nullptr;
return &nodeContainer[node->leftChild]; return &nodeContainer[index];
} }
Node* rightChild(Node* node) inline bool isValid(size_t index) const
{ {
if(node->rightChild >= nodeContainer.size()) return nullptr; return index < nodeContainer.size();
return &nodeContainer[node->rightChild];
}
Node* leftChild(Node* node) const
{
if(node->leftChild >= nodeContainer.size()) return nullptr;
return &nodeContainer[node->leftChild];
}
Node* rightChild(Node* node) const
{
if(node->rightChild >= nodeContainer.size()) return nullptr;
return &nodeContainer[node->rightChild];
} }
void markIteratorDirty() void markIteratorDirty()
{ {
@@ -405,192 +407,201 @@ private:
} }
inline Iterator calcBeginIterator() const inline Iterator calcBeginIterator() const
{ {
if (root == nullptr) if (!isValid(root))
{ {
return Iterator(nullptr); return Iterator(-1, &nodeContainer);
} }
else else
{ {
size_t beginIndex = root->self; size_t beginIndex = root;
Array<size_t> beginTraversal; Array<size_t> beginTraversal;
while (beginIndex < nodeContainer.size()) while (isValid(beginIndex))
{ {
beginTraversal.add(beginIndex); beginTraversal.add(beginIndex);
beginIndex = nodeContainer[beginIndex].leftChild; beginIndex = getNode(beginIndex)->leftChild;
} }
Node* beginNode = &nodeContainer[beginTraversal.back()]; beginIndex = beginTraversal.back();
beginTraversal.pop(); beginTraversal.pop();
return Iterator(beginNode, std::move(beginTraversal), &nodeContainer); return Iterator(beginIndex, &nodeContainer, std::move(beginTraversal));
} }
} }
inline Iterator calcEndIterator() const inline Iterator calcEndIterator() const
{ {
if (root == nullptr) if (!isValid(root))
{ {
return Iterator(nullptr); return Iterator(-1, &nodeContainer);
} }
else else
{ {
size_t endIndex = root->self; size_t endIndex = root;
Array<size_t> endTraversal; Array<size_t> endTraversal;
while (endIndex < nodeContainer.size()) while (isValid(endIndex))
{ {
endTraversal.add(endIndex); endTraversal.add(endIndex);
endIndex = nodeContainer[endIndex].rightChild; endIndex = getNode(endIndex)->rightChild;
} }
return Iterator(nullptr, std::move(endTraversal), &nodeContainer); return Iterator(-1, &nodeContainer, std::move(endTraversal));
} }
} }
Array<Node, NodeAlloc> nodeContainer; Array<Node, NodeAlloc> nodeContainer;
Node *root; size_t root;
Iterator beginIt; Iterator beginIt;
Iterator endIt; Iterator endIt;
bool iteratorsDirty; bool iteratorsDirty;
uint32 _size; uint32 _size;
Compare comp; Compare comp;
Node *rotateRight(Node *node) size_t rotateRight(size_t node)
{ {
Node *y = leftChild(node); Node* x = getNode(node);
node->leftChild = y->rightChild; size_t res = x->leftChild;
y->rightChild = node->self; Node* y = getNode(x->leftChild);
return y; x->leftChild = y->rightChild;
y->rightChild = node;
return res;
} }
Node *rotateLeft(Node *node) size_t rotateLeft(size_t node)
{ {
Node *y = rightChild(node); Node* x = getNode(node);
node->rightChild = y->leftChild; size_t res = x->rightChild;
y->leftChild = node->self; Node* y = getNode(x->rightChild);
return y; x->rightChild = y->leftChild;
y->leftChild = node;
return res;
} }
template<class KeyType> template<class KeyType>
Node *insert(Node *r, KeyType&& key) size_t insert(size_t r, KeyType&& key)
{ {
if (r == nullptr) if (!isValid(r))
{ {
return &nodeContainer.emplace(nodeContainer.size(), std::forward<KeyType>(key)); nodeContainer.emplace(std::forward<KeyType>(key));
return 0;
} }
r = splay(r, key); r = splay(r, key);
if (!(comp(r->pair.key, key) || comp(key, r->pair.key))) if (!(comp(node->pair.key, key) || comp(key, node->pair.key)))
return r; return r;
Node *newNode = &nodeContainer.emplace(nodeContainer.size(), std::forward<KeyType>(key)); Node* node = getNode(r);
Node *newNode = &nodeContainer.emplace(std::forward<KeyType>(key));
if (comp(key, r->pair.key)) if (comp(key, node->pair.key))
{ {
newNode->rightChild = r->self; newNode->rightChild = r;
newNode->leftChild = r->leftChild; newNode->leftChild = node->leftChild;
r->leftChild = -1; node->leftChild = -1;
} }
else else
{ {
newNode->leftChild = r->self; newNode->leftChild = r;
newNode->rightChild = r->rightChild; newNode->rightChild = node->rightChild;
r->rightChild = -1; node->rightChild = -1;
} }
return newNode; return nodeContainer.size() - 1;
} }
template<class KeyType> template<class KeyType>
Node *remove(Node *r, KeyType&& key) size_t remove(size_t r, KeyType&& key)
{ {
Node *temp; size_t temp;
if (!r) if (!isValid(r))
return nullptr; return -1;
r = splay(r, key); r = splay(r, key);
Node* node = getNode(r);
if (comp(r->pair.key, key) || comp(key, r->pair.key)) if (comp(node->pair.key, key) || comp(key, node->pair.key))
return r; return r;
if (r->leftChild == -1) if (!isValid(node->leftChild))
{ {
temp = r; temp = r;
r = rightChild(r); r = node->rightChild;
} }
else else
{ {
temp = r; temp = r;
r = splay(leftChild(r), key); r = splay(node->leftChild, key);
r->rightChild = temp->rightChild; node = getNode(r);
node->rightChild = getNode(temp)->rightChild;
} }
Node& lastNode = nodeContainer.back(); Node& lastNode = nodeContainer.back();
size_t removedIndex = temp->self; size_t lastIndex = nodeContainer.size() - 1;
size_t removedIndex = temp;
//Arrays can only pop back, so we need to move the last element to the deleted index //Arrays can only pop back, so we need to move the last element to the deleted index
if(removedIndex != lastNode.self) if(removedIndex != lastIndex)
{ {
nodeContainer[removedIndex] = std::move(lastNode); nodeContainer[removedIndex] = std::move(lastNode);
for(auto it : nodeContainer) for(auto& it : nodeContainer)
{ {
if(it.leftChild == lastNode.self) if(it.leftChild == lastIndex)
{ {
it.leftChild = removedIndex; it.leftChild = removedIndex;
} }
if(it.rightChild == lastNode.self) if(it.rightChild == lastIndex)
{ {
it.rightChild = removedIndex; it.rightChild = removedIndex;
} }
} }
lastNode.self = removedIndex;
} }
nodeContainer.pop(); nodeContainer.pop();
_size--; _size--;
return r; return r;
} }
template<class KeyType> template<class KeyType>
Node *splay(Node *r, KeyType&& key) size_t splay(size_t r, KeyType&& key)
{ {
if (r == nullptr || !(comp(r->pair.key, key) || comp(key, r->pair.key))) Node* node = getNode(r);
if (node == nullptr
|| !(comp(node->pair.key, key)
|| comp(key, node->pair.key)))
{ {
return r; return r;
} }
if (comp(key, node->pair.key))
if (comp(key, r->pair.key))
{ {
if (r->leftChild >= nodeContainer.size()) if (!isValid(node->leftChild))
return r; return r;
if (comp(key, leftChild(r)->pair.key)) if (comp(key, getNode(node->leftChild)->pair.key))
{ {
Node* res = splay(leftChild(leftChild(r)), key); getNode(node->leftChild)->leftChild = splay(getNode(node->leftChild)->leftChild, key);
leftChild(r)->leftChild = res ? res->self : -1;
r = rotateRight(r); r = rotateRight(r);
node = getNode(r);
} }
else if (comp(leftChild(r)->pair.key, key)) else if (comp(getNode(node->leftChild)->pair.key, key))
{ {
Node* res = splay(rightChild(leftChild(r)), key); getNode(node->leftChild)->rightChild = splay(getNode(node->leftChild)->rightChild, key);
leftChild(r)->rightChild = res ? res->self : -1;
if (leftChild(r)->rightChild < nodeContainer.size()) if (isValid(getNode(node->leftChild)->rightChild))
{ {
r->leftChild = rotateLeft(leftChild(r))->self; node->leftChild = rotateLeft(node->leftChild);
} }
} }
return (r->leftChild >= nodeContainer.size()) ? r : rotateRight(r); return (!isValid(node->leftChild)) ? r : rotateRight(r);
} }
else else
{ {
if (r->rightChild >= nodeContainer.size()) if (!isValid(node->rightChild))
return r; return r;
if (comp(key, rightChild(r)->pair.key)) if (comp(key, getNode(node->rightChild)->pair.key))
{ {
Node* res = splay(leftChild(rightChild(r)), key); getNode(node->rightChild)->leftChild = splay(getNode(node->rightChild)->leftChild, key);
rightChild(r)->leftChild = res ? res->self : -1;
if (rightChild(r)->leftChild < nodeContainer.size()) if (isValid(getNode(node->rightChild)->leftChild))
{ {
r->rightChild = rotateRight(rightChild(r))->self; node->rightChild = rotateRight(node->rightChild);
} }
} }
else if (comp(rightChild(r)->pair.key, key)) else if (comp(getNode(node->rightChild)->pair.key, key))
{ {
Node* res = splay(rightChild(rightChild(r)), key); getNode(node->rightChild)->rightChild = splay(getNode(node->rightChild)->rightChild, key);
rightChild(r)->rightChild = res ? res->self : -1;
r = rotateLeft(r); r = rotateLeft(r);
node = getNode(r);
} }
return (r->rightChild >= nodeContainer.size()) ? r : rotateLeft(r); return (!isValid(node->rightChild)) ? r : rotateLeft(r);
} }
} }
}; };
src/Engine/Graphics/Vulkan/VulkanAllocator.cpp
+1 -1
View File
@@ -124,7 +124,7 @@ PSubAllocation Allocation::getSuballocation(VkDeviceSize requestedSize, VkDevice
void Allocation::markFree(SubAllocation *allocation) void Allocation::markFree(SubAllocation *allocation)
{ {
// Dont free if it is already a free allocation, since they also mark themselves on deletion // Dont free if it is already a free allocation, since they also mark themselves on deletion
if (freeRanges.find(allocation->allocatedOffset) != nullptr) if (freeRanges.find(allocation->allocatedOffset) != freeRanges.end())
{ {
return; return;
} }