summaryrefslogtreecommitdiffstats
path: root/external/optick/optick_memory.h
diff options
context:
space:
mode:
Diffstat (limited to 'external/optick/optick_memory.h')
-rw-r--r--external/optick/optick_memory.h419
1 files changed, 0 insertions, 419 deletions
diff --git a/external/optick/optick_memory.h b/external/optick/optick_memory.h
deleted file mode 100644
index 45249c6..0000000
--- a/external/optick/optick_memory.h
+++ /dev/null
@@ -1,419 +0,0 @@
-#pragma once
-
-#include "optick_common.h"
-
-#if USE_OPTICK
-
-#include <cstring>
-#include <new>
-#include <stdlib.h>
-#include <atomic>
-
-#include <array>
-#include <list>
-#include <string>
-#include <sstream>
-#include <unordered_set>
-#include <unordered_map>
-#include <vector>
-
-namespace Optick
-{
- class Memory
- {
- struct Header
- {
- uint64_t size;
- };
-
- static std::atomic<uint64_t> memAllocated;
-
- static void* (*allocate)(size_t);
- static void (*deallocate)(void* p);
- public:
- static OPTICK_INLINE void* Alloc(size_t size)
- {
- size_t totalSize = size + sizeof(Header);
- void *ptr = allocate(totalSize);
- OPTICK_VERIFY(ptr, "Can't allocate memory", return nullptr);
-
- Header* header = (Header*)ptr;
- header->size = totalSize;
- memAllocated += totalSize;
-
- return (uint8_t*)ptr + sizeof(Header);
- }
-
- static OPTICK_INLINE void Free(void* p)
- {
- if (p != nullptr)
- {
- uint8_t* basePtr = (uint8_t*)p - sizeof(Header);
- Header* header = (Header*)basePtr;
- memAllocated -= header->size;
- deallocate(basePtr);
- }
- }
-
- static OPTICK_INLINE size_t GetAllocatedSize()
- {
- return (size_t)memAllocated;
- }
-
- template<class T>
- static T* New()
- {
- return new (Memory::Alloc(sizeof(T))) T();
- }
-
- template<class T, class P1>
- static T* New(P1 p1)
- {
- return new (Memory::Alloc(sizeof(T))) T(p1);
- }
-
- template<class T, class P1, class P2>
- static T* New(P1 p1, P2 p2)
- {
- return new (Memory::Alloc(sizeof(T))) T(p1, p2);
- }
-
- template<class T>
- static void Delete(T* p)
- {
- if (p)
- {
- p->~T();
- Free(p);
- }
- }
-
- static void SetAllocator(void* (*allocateFn)(size_t), void(*deallocateFn)(void*))
- {
- allocate = allocateFn;
- deallocate = deallocateFn;
- }
-
- template<typename T>
- struct Allocator : public std::allocator<T>
- {
- Allocator() {}
- template<class U>
- Allocator(const Allocator<U>&) {}
- template<typename U> struct rebind { typedef Allocator<U> other; };
-
- typename std::allocator<T>::pointer allocate(typename std::allocator<T>::size_type n, typename std::allocator<void>::const_pointer = 0)
- {
- return reinterpret_cast<typename std::allocator<T>::pointer>(Memory::Alloc(n * sizeof(T)));
- }
-
- void deallocate(typename std::allocator<T>::pointer p, typename std::allocator<T>::size_type)
- {
- Memory::Free(p);
- }
- };
- };
-
- // std::* section
- template <typename T, size_t _Size> class array : public std::array<T, _Size>{};
- template <typename T> class vector : public std::vector<T, Memory::Allocator<T>>{};
- template <typename T> class list : public std::list<T, Memory::Allocator<T>>{};
- template <typename T> class unordered_set : public std::unordered_set<T, std::hash<T>, std::equal_to<T>, Memory::Allocator<T>>{};
- template <typename T, typename V> class unordered_map : public std::unordered_map<T, V, std::hash<T>, std::equal_to<T>, Memory::Allocator<std::pair<const T, V>>>{};
-
- using string = std::basic_string<char, std::char_traits<char>, Memory::Allocator<char>>;
- using wstring = std::basic_string<wchar_t, std::char_traits<wchar_t>, Memory::Allocator<wchar_t>>;
-
- using istringstream = std::basic_istringstream<char, std::char_traits<char>, Memory::Allocator<char>>;
- using ostringstream = std::basic_ostringstream<char, std::char_traits<char>, Memory::Allocator<char>>;
- using stringstream = std::basic_stringstream<char, std::char_traits<char>, Memory::Allocator<char>>;
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- template<class T, uint32 SIZE>
- struct MemoryChunk
- {
- OPTICK_ALIGN_CACHE T data[SIZE];
- MemoryChunk* next;
- MemoryChunk* prev;
-
- MemoryChunk() : next(0), prev(0) {}
-
- ~MemoryChunk()
- {
- MemoryChunk* chunk = this;
- while (chunk->next)
- chunk = chunk->next;
-
- while (chunk != this)
- {
- MemoryChunk* toDelete = chunk;
- chunk = toDelete->prev;
- Memory::Delete(toDelete);
- }
-
- if (prev != nullptr)
- {
- prev->next = nullptr;
- prev = nullptr;
- }
- }
- };
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- template<class T, uint32 SIZE = 16>
- class MemoryPool
- {
- typedef MemoryChunk<T, SIZE> Chunk;
- Chunk* root;
- Chunk* chunk;
- uint32 index;
-
- OPTICK_INLINE void AddChunk()
- {
- index = 0;
- if (!chunk || !chunk->next)
- {
- Chunk* newChunk = Memory::New<Chunk>();
- if (chunk)
- {
- chunk->next = newChunk;
- newChunk->prev = chunk;
- chunk = newChunk;
- }
- else
- {
- root = chunk = newChunk;
- }
- }
- else
- {
- chunk = chunk->next;
- }
- }
- public:
- MemoryPool() : root(nullptr), chunk(nullptr), index(SIZE) {}
-
- OPTICK_INLINE T& Add()
- {
- if (index >= SIZE)
- AddChunk();
-
- return chunk->data[index++];
- }
-
- OPTICK_INLINE T& Add(const T& item)
- {
- return Add() = item;
- }
-
- OPTICK_INLINE T* AddRange(const T* items, size_t count, bool allowOverlap = true)
- {
- if (count == 0 || (count > SIZE && !allowOverlap))
- return nullptr;
-
- if (count >= (SIZE - index) && !allowOverlap)
- {
- AddChunk();
- }
-
- T* result = &chunk->data[index];
-
- while (count)
- {
- size_t numLeft = SIZE - index;
- size_t numCopy = numLeft < count ? numLeft : count;
- std::memcpy(&chunk->data[index], items, sizeof(T) * numCopy);
-
- count -= numCopy;
- items += numCopy;
- index += (uint32_t)numCopy;
-
- if (count)
- AddChunk();
- }
-
- return result;
- }
-
-
- OPTICK_INLINE T* TryAdd(int count)
- {
- if (index + count <= SIZE)
- {
- T* res = &chunk->data[index];
- index += count;
- return res;
- }
-
- return nullptr;
- }
-
- OPTICK_INLINE T* Back()
- {
- if (chunk && index > 0)
- return &chunk->data[index - 1];
-
- if (chunk && chunk->prev != nullptr)
- return &chunk->prev->data[SIZE - 1];
-
- return nullptr;
- }
-
- OPTICK_INLINE size_t Size() const
- {
- if (root == nullptr)
- return 0;
-
- size_t count = 0;
-
- for (const Chunk* it = root; it != chunk; it = it->next)
- count += SIZE;
-
- return count + index;
- }
-
- OPTICK_INLINE bool IsEmpty() const
- {
- return (chunk == nullptr) || (chunk == root && index == 0);
- }
-
- OPTICK_INLINE void Clear(bool preserveMemory = true)
- {
- if (!preserveMemory)
- {
- if (root)
- {
- Memory::Delete(root);
- root = nullptr;
- chunk = nullptr;
- index = SIZE;
- }
- }
- else if (root)
- {
- index = 0;
- chunk = root;
- }
- }
-
- class const_iterator
- {
- void advance()
- {
- if (chunkIndex < SIZE - 1)
- {
- ++chunkIndex;
- }
- else
- {
- chunkPtr = chunkPtr->next;
- chunkIndex = 0;
- }
- }
- public:
- typedef const_iterator self_type;
- typedef T value_type;
- typedef T& reference;
- typedef T* pointer;
- typedef int difference_type;
- const_iterator(const Chunk* ptr, size_t index) : chunkPtr(ptr), chunkIndex(index) { }
- self_type operator++()
- {
- self_type i = *this;
- advance();
- return i;
- }
- self_type operator++(int /*junk*/)
- {
- advance();
- return *this;
- }
- reference operator*() { return (reference)chunkPtr->data[chunkIndex]; }
- const pointer operator->() { return &chunkPtr->data[chunkIndex]; }
- bool operator==(const self_type& rhs) { return (chunkPtr == rhs.chunkPtr) && (chunkIndex == rhs.chunkIndex); }
- bool operator!=(const self_type& rhs) { return (chunkPtr != rhs.chunkPtr) || (chunkIndex != rhs.chunkIndex); }
- private:
- const Chunk* chunkPtr;
- size_t chunkIndex;
- };
-
- const_iterator begin() const
- {
- return const_iterator(root, 0);
- }
-
- const_iterator end() const
- {
- return const_iterator(chunk, index);
- }
-
- template<class Func>
- void ForEach(Func func) const
- {
- for (const Chunk* it = root; it != chunk; it = it->next)
- for (uint32 i = 0; i < SIZE; ++i)
- func(it->data[i]);
-
- if (chunk)
- for (uint32 i = 0; i < index; ++i)
- func(chunk->data[i]);
- }
-
- template<class Func>
- void ForEach(Func func)
- {
- for (Chunk* it = root; it != chunk; it = it->next)
- for (uint32 i = 0; i < SIZE; ++i)
- func(it->data[i]);
-
- if (chunk)
- for (uint32 i = 0; i < index; ++i)
- func(chunk->data[i]);
- }
-
- template<class Func>
- void ForEachChunk(Func func) const
- {
- for (const Chunk* it = root; it != chunk; it = it->next)
- func(it->data, SIZE);
-
- if (chunk)
- func(chunk->data, index);
- }
-
- void ToArray(T* destination) const
- {
- uint32 curIndex = 0;
-
- for (const Chunk* it = root; it != chunk; it = it->next)
- {
- memcpy(&destination[curIndex], it->data, sizeof(T) * SIZE);
- curIndex += SIZE;
- }
-
- if (chunk && index > 0)
- {
- memcpy(&destination[curIndex], chunk->data, sizeof(T) * index);
- }
- }
- };
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- template<uint32 CHUNK_SIZE>
- class MemoryBuffer : private MemoryPool<uint8, CHUNK_SIZE>
- {
- public:
- template<class U>
- U* Add(U* data, size_t size, bool allowOverlap = true)
- {
- return (U*)(MemoryPool<uint8, CHUNK_SIZE>::AddRange((uint8*)data, size, allowOverlap));
- }
-
- template<class T>
- T* Add(const T& val, bool allowOverlap = true)
- {
- return static_cast<T*>(Add(&val, sizeof(T), allowOverlap));
- }
- };
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-}
-
-#endif //USE_OPTICK \ No newline at end of file
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-13 02:19:04 +0100