fix: breakpad use miniz

third_party/tracy/server/TracySlab.hpp

@@ -0,0 +1,159 @@
+#ifndef __TRACYSLAB_HPP__
+#define __TRACYSLAB_HPP__
+
+#include <assert.h>
+#include <stdint.h>
+#include <vector>
+
+#include "TracyMemory.hpp"
+#include "../public/common/TracyForceInline.hpp"
+
+namespace tracy
+{
+
+template<size_t BlockSize>
+class Slab
+{
+public:
+    Slab()
+        : m_ptr( new char[BlockSize] )
+        , m_offset( 0 )
+        , m_buffer( { m_ptr } )
+        , m_usage( BlockSize )
+    {
+        memUsage.fetch_add( BlockSize, std::memory_order_relaxed );
+    }
+
+    ~Slab()
+    {
+        memUsage.fetch_sub( m_usage, std::memory_order_relaxed );
+        for( auto& v : m_buffer )
+        {
+            delete[] v;
+        }
+    }
+
+    tracy_force_inline void* AllocRaw( size_t size )
+    {
+        assert( size <= BlockSize );
+        const auto offset = m_offset;
+        if( offset + size > BlockSize )
+        {
+            return DoAlloc( size );
+        }
+        else
+        {
+            void* ret = m_ptr + offset;
+            m_offset += size;
+            return ret;
+        }
+    }
+
+    template<typename T>
+    tracy_force_inline T* AllocInit()
+    {
+        const auto size = sizeof( T );
+        auto ret = AllocRaw( size );
+        new( ret ) T;
+        return (T*)ret;
+    }
+
+    template<typename T>
+    tracy_force_inline T* AllocInit( size_t sz )
+    {
+        const auto size = sizeof( T ) * sz;
+        auto ret = AllocRaw( size );
+        T* ptr = (T*)ret;
+        for( size_t i=0; i<sz; i++ )
+        {
+            new( ptr ) T;
+            ptr++;
+        }
+        return (T*)ret;
+    }
+
+    template<typename T>
+    tracy_force_inline T* Alloc()
+    {
+        return (T*)AllocRaw( sizeof( T ) );
+    }
+
+    template<typename T>
+    tracy_force_inline T* Alloc( size_t size )
+    {
+        return (T*)AllocRaw( sizeof( T ) * size );
+    }
+
+    tracy_force_inline void Unalloc( size_t size )
+    {
+        assert( size <= m_offset );
+        m_offset -= size;
+    }
+
+    tracy_force_inline void* AllocBig( size_t size )
+    {
+        const auto offset = m_offset;
+        if( offset + size <= BlockSize )
+        {
+            void* ret = m_ptr + offset;
+            m_offset += size;
+            return ret;
+        }
+        else if( size <= BlockSize && BlockSize - offset <= 1024 )
+        {
+            return DoAlloc( size );
+        }
+        else
+        {
+            memUsage.fetch_add( size, std::memory_order_relaxed );
+            m_usage += size;
+            auto ret = new char[size];
+            m_buffer.emplace_back( ret );
+            return ret;
+        }
+    }
+
+    void Reset()
+    {
+        if( m_buffer.size() > 1 )
+        {
+            memUsage.fetch_sub( m_usage - BlockSize, std::memory_order_relaxed );
+            m_usage = BlockSize;
+            for( int i=1; i<m_buffer.size(); i++ )
+            {
+                delete[] m_buffer[i];
+            }
+            m_ptr = m_buffer[0];
+            m_buffer.clear();
+            m_buffer.emplace_back( m_ptr );
+        }
+        m_offset = 0;
+    }
+
+    Slab( const Slab& ) = delete;
+    Slab( Slab&& ) = delete;
+
+    Slab& operator=( const Slab& ) = delete;
+    Slab& operator=( Slab&& ) = delete;
+
+private:
+    void* DoAlloc( uint32_t willUseBytes )
+    {
+        auto ptr = new char[BlockSize];
+        m_ptr = ptr;
+        m_offset = willUseBytes;
+        m_buffer.emplace_back( m_ptr );
+        memUsage.fetch_add( BlockSize, std::memory_order_relaxed );
+        m_usage += BlockSize;
+        return ptr;
+    }
+
+    char* m_ptr;
+    uint32_t m_offset;
+    std::vector<char*> m_buffer;
+    size_t m_usage;
+};
+
+}
+
+#endif