Ran format

Author: Raelr

engine/utils/allocators/Tlsf.cpp

@@ -8,7 +8,9 @@
 //
 
 #include "Tlsf.h"
+
 #include <memory>
+
 #include "../Logging.h"
 
 #define TO_BYTES(val) reinterpret_cast<uint8_t*>(val)
@@ -35,7 +37,8 @@ template<typename T>
 uint8_t TlsfAllocator<T>::MIN_SIZE_INDEX = 4;
 
 template<typename T>
-TlsfAllocator<T>::TlsfAllocator() {}
+TlsfAllocator<T>::TlsfAllocator()
+{}
 
 template<typename T>
 TlsfAllocator<T>::TlsfAllocator(const T size)
@@ -139,8 +142,9 @@ void TlsfAllocator<T>::Deallocate(void** ptr)
 }
 
 template<typename T>
-typename TlsfAllocator<T>::BlockHeader* TlsfAllocator<T>::TrySplitBlock(TlsfAllocator<T>::FreeBlockNode* node,
-                                                         T& allocatedSize)
+typename TlsfAllocator<T>::BlockHeader* TlsfAllocator<T>::TrySplitBlock(
+    TlsfAllocator<T>::FreeBlockNode* node,
+    T& allocatedSize)
 {
     if (!node) return nullptr;
 
@@ -182,7 +186,8 @@ void TlsfAllocator<T>::AddNewBlock(const T size, BlockHeader* header)
 }
 
 template<typename T>
-typename TlsfAllocator<T>::BlockHeader* TlsfAllocator<T>::TryCoalesce(BlockHeader* header, OUT T& size)
+typename TlsfAllocator<T>::BlockHeader* TlsfAllocator<T>::TryCoalesce(BlockHeader* header,
+                                                                      OUT T& size)
 {
     BlockHeader* start = header;
     BlockHeader* prev = GetPrevHeader(start);
@@ -284,7 +289,8 @@ void TlsfAllocator<T>::CreateFooter(uint8_t* ptr, const T size)
 }
 
 template<typename T>
-typename TlsfAllocator<T>::BlockHeader* TlsfAllocator<T>::GetHeader(TlsfAllocator::FreeBlockNode* node)
+typename TlsfAllocator<T>::BlockHeader* TlsfAllocator<T>::GetHeader(
+    TlsfAllocator::FreeBlockNode* node)
 {
     if (!node) return nullptr;
     uint8_t* rawHeader = TO_BYTES(node) - HEADER_SIZE;
@@ -302,7 +308,8 @@ typename TlsfAllocator<T>::BlockHeader* TlsfAllocator<T>::GetHeader(uint8_t* ptr
 }
 
 template<typename T>
-typename TlsfAllocator<T>::BlockHeader* TlsfAllocator<T>::GetPrevHeader(TlsfAllocator::BlockHeader* header)
+typename TlsfAllocator<T>::BlockHeader* TlsfAllocator<T>::GetPrevHeader(
+    TlsfAllocator::BlockHeader* header)
 {
     if (!header) return nullptr;
     uint8_t* rawPrevFooter = TO_BYTES(GetPrevFooter(header));
@@ -313,7 +320,8 @@ typename TlsfAllocator<T>::BlockHeader* TlsfAllocator<T>::GetPrevHeader(TlsfAllo
 }
 
 template<typename T>
-typename TlsfAllocator<T>::BlockHeader* TlsfAllocator<T>::GetNextHeader(TlsfAllocator::BlockHeader* header)
+typename TlsfAllocator<T>::BlockHeader* TlsfAllocator<T>::GetNextHeader(
+    TlsfAllocator::BlockHeader* header)
 {
     if (!header) return nullptr;
     uint8_t* rawHeader = TO_BYTES(header);
@@ -323,9 +331,10 @@ typename TlsfAllocator<T>::BlockHeader* TlsfAllocator<T>::GetNextHeader(TlsfAllo
 }
 
 template<typename T>
-typename TlsfAllocator<T>::FreeBlockNode* TlsfAllocator<T>::CreateFreeBlock(uint8_t* ptr,
-                                                             TlsfAllocator::FreeBlockNode* prev,
-                                                             TlsfAllocator::FreeBlockNode* next)
+typename TlsfAllocator<T>::FreeBlockNode* TlsfAllocator<T>::CreateFreeBlock(
+    uint8_t* ptr,
+    TlsfAllocator::FreeBlockNode* prev,
+    TlsfAllocator::FreeBlockNode* next)
 {
     if (!IsValid(ptr)) return nullptr;
 
@@ -351,7 +360,8 @@ typename TlsfAllocator<T>::FreeBlockNode* TlsfAllocator<T>::GetFreeBlock(const T
 }
 
 template<typename T>
-typename TlsfAllocator<T>::BlockFooter* TlsfAllocator<T>::GetFooter(TlsfAllocator::BlockHeader* header)
+typename TlsfAllocator<T>::BlockFooter* TlsfAllocator<T>::GetFooter(
+    TlsfAllocator::BlockHeader* header)
 {
     if (!header) return nullptr;
     T size = GetHeaderSize(header);
@@ -361,7 +371,8 @@ typename TlsfAllocator<T>::BlockFooter* TlsfAllocator<T>::GetFooter(TlsfAllocato
 }
 
 template<typename T>
-typename TlsfAllocator<T>::BlockFooter* TlsfAllocator<T>::GetPrevFooter(TlsfAllocator::BlockHeader* header)
+typename TlsfAllocator<T>::BlockFooter* TlsfAllocator<T>::GetPrevFooter(
+    TlsfAllocator::BlockHeader* header)
 {
     if (!header) return nullptr;
     uint8_t* rawFooter = TO_BYTES(header) - FOOTER_SIZE;
@@ -393,6 +404,12 @@ bool TlsfAllocator<T>::IsFree(T fl, T sl)
     return slBitmasks[fl] & (1 << sl);
 }
 
+template<typename T>
+bool TlsfAllocator<T>::IsFull()
+{
+    return totalBytesRemaining == 0;
+}
+
 template<typename T>
 bool TlsfAllocator<T>::PrevBlockIsFree(BlockHeader* header)
 {
@@ -429,5 +446,4 @@ const T TlsfAllocator<T>::BytesRemaining()
 template class TlsfAllocator<uint16_t>;
 template class TlsfAllocator<uint32_t>;
 template class TlsfAllocator<uint64_t>;
-}
-
+} // namespace Siege

engine/utils/allocators/Tlsf.h

@@ -14,14 +14,15 @@
 
 #include "../Macros.h"
 
-#define FREE(ptr) Deallocate((void**)&ptr)
+#define FREE(ptr) Deallocate((void**) &ptr)
 
 namespace Siege
 {
 template<typename T>
 class TlsfAllocator
 {
 public:
+
     enum HeaderFlags
     {
         FULL = 0,
@@ -65,6 +66,7 @@ class TlsfAllocator
     const T GetNextFreeSlotIndex(T& fl, T& sl);
     bool IsFree(BlockHeader* header);
     bool IsFree(T fl, T sl);
+    bool IsFull();
     bool PrevBlockIsFree(BlockHeader* header);
     T CalculateFreeBlockIndices(T size, OUT T& fl, OUT T& sl);
 
@@ -141,6 +143,6 @@ typedef TlsfAllocator<uint16_t> SmallTlsfAllocator;
 typedef TlsfAllocator<uint32_t> MediumTlsfAllocator;
 // Maximum buffer possible here is around 2,147,483.6GB.
 typedef TlsfAllocator<uint64_t> LargeTlsfAllocator;
-}
+} // namespace Siege
 
 #endif // SIEGE_ENGINE_TLSF_H

tests/src/resources/test_ResourceSystem.cpp

@@ -17,8 +17,6 @@
 #include <resources/Texture2DData.h>
 #include <utest.h>
 
-#include <random>
-
 using namespace Siege;
 
 // Define test fixture

tests/src/utils/test_TlsfAllocator.cpp

@@ -113,9 +113,9 @@ UTEST(test_MediumTlsfAllocator, TestAllocateFunction)
 
     ASSERT_EQ(192, strHeader->sizeAndFlags);
     ASSERT_EQ(strData, str);
-    ASSERT_EQ(
-        sizeof(MediumTlsfAllocator::BlockHeader) + sizeof(String) + sizeof(MediumTlsfAllocator::BlockFooter),
-        strFooter->totalBlockSize);
+    ASSERT_EQ(sizeof(MediumTlsfAllocator::BlockHeader) + sizeof(String) +
+                  sizeof(MediumTlsfAllocator::BlockFooter),
+              strFooter->totalBlockSize);
     ASSERT_EQ(32, a.BytesRemaining());
 
     // Edge cases
@@ -258,9 +258,9 @@ UTEST(Test_MediumTlsfAllocator, TestDeallocateFunction)
 
     ASSERT_EQ(192, strHeader->sizeAndFlags);
     ASSERT_EQ(strData, str);
-    ASSERT_EQ(
-        sizeof(MediumTlsfAllocator::BlockHeader) + sizeof(String) + sizeof(MediumTlsfAllocator::BlockFooter),
-        strFooter->totalBlockSize);
+    ASSERT_EQ(sizeof(MediumTlsfAllocator::BlockHeader) + sizeof(String) +
+                  sizeof(MediumTlsfAllocator::BlockFooter),
+              strFooter->totalBlockSize);
     ASSERT_EQ(32, a.BytesRemaining());
 
     a.FREE(p);
@@ -425,6 +425,7 @@ UTEST(Test_MediumTlsfAllocator, TestAllocationWhenNoAppropriateFragmentExists)
     void* p2 = a.Allocate(16);
     void* p3 = a.Allocate(32);
     ASSERT_EQ(0, a.TotalBytesRemaining());
+    ASSERT_TRUE(a.IsFull());
 
     a.FREE(p0);
     a.FREE(p2);
@@ -581,9 +582,9 @@ UTEST(Test_SmallTlsfAllocator, TestAllocateFunction)
 
     ASSERT_EQ(160, strHeader->sizeAndFlags);
     ASSERT_EQ(strData, str);
-    ASSERT_EQ(
-        sizeof(SmallTlsfAllocator::BlockHeader) + sizeof(String) + sizeof(SmallTlsfAllocator::BlockFooter),
-        strFooter->totalBlockSize);
+    ASSERT_EQ(sizeof(SmallTlsfAllocator::BlockHeader) + sizeof(String) +
+                  sizeof(SmallTlsfAllocator::BlockFooter),
+              strFooter->totalBlockSize);
     ASSERT_EQ(32, a.BytesRemaining());
 
     // Edge cases
@@ -726,9 +727,9 @@ UTEST(Test_SmallTlsfAllocator, TestDeallocateFunction)
 
     ASSERT_EQ(160, strHeader->sizeAndFlags);
     ASSERT_EQ(strData, str);
-    ASSERT_EQ(
-        sizeof(SmallTlsfAllocator::BlockHeader) + sizeof(String) + sizeof(SmallTlsfAllocator::BlockFooter),
-        strFooter->totalBlockSize);
+    ASSERT_EQ(sizeof(SmallTlsfAllocator::BlockHeader) + sizeof(String) +
+                  sizeof(SmallTlsfAllocator::BlockFooter),
+              strFooter->totalBlockSize);
     ASSERT_EQ(32, a.BytesRemaining());
 
     a.FREE(p);
@@ -893,6 +894,7 @@ UTEST(Test_SmallTlsfAllocator, TestAllocationWhenNoAppropriateFragmentExists)
     void* p2 = a.Allocate(20);
     void* p3 = a.Allocate(36);
     ASSERT_EQ(0, a.TotalBytesRemaining());
+    ASSERT_TRUE(a.IsFull());
 
     a.FREE(p0);
     a.FREE(p2);
@@ -1049,9 +1051,9 @@ UTEST(Test_LargeTlsfAllocator, TestAllocateFunction)
 
     ASSERT_EQ(256, strHeader->sizeAndFlags);
     ASSERT_EQ(strData, str);
-    ASSERT_EQ(
-        sizeof(LargeTlsfAllocator::BlockHeader) + sizeof(String) + sizeof(LargeTlsfAllocator::BlockFooter),
-        strFooter->totalBlockSize);
+    ASSERT_EQ(sizeof(LargeTlsfAllocator::BlockHeader) + sizeof(String) +
+                  sizeof(LargeTlsfAllocator::BlockFooter),
+              strFooter->totalBlockSize);
     ASSERT_EQ(224, a.BytesRemaining());
 
     // Edge cases
@@ -1191,9 +1193,9 @@ UTEST(Test_LargeTlsfAllocator, TestDeallocateFunction)
 
     ASSERT_EQ(256, strHeader->sizeAndFlags);
     ASSERT_EQ(strData, str);
-    ASSERT_EQ(
-        sizeof(LargeTlsfAllocator::BlockHeader) + sizeof(String) + sizeof(LargeTlsfAllocator::BlockFooter),
-        strFooter->totalBlockSize);
+    ASSERT_EQ(sizeof(LargeTlsfAllocator::BlockHeader) + sizeof(String) +
+                  sizeof(LargeTlsfAllocator::BlockFooter),
+              strFooter->totalBlockSize);
     ASSERT_EQ(224, a.BytesRemaining());
 
     a.FREE(p);
@@ -1358,6 +1360,7 @@ UTEST(Test_LargeTlsfAllocator, TestAllocationWhenNoAppropriateFragmentExists)
     void* p2 = a.Allocate(32);
     void* p3 = a.Allocate(64);
     ASSERT_EQ(0, a.TotalBytesRemaining());
+    ASSERT_TRUE(a.IsFull());
 
     a.FREE(p0);
     a.FREE(p2);