Memory: Add scratch allocator + it unittests.

Author: kullingk

CMakeLists.txt

@@ -150,6 +150,7 @@ IF( CPPCORE_BUILD_UNITTESTS )
     SET( cppcore_memory_test_src
         test/memory/TStackAllocatorTest.cpp
         test/memory/TPoolAllocatorTest.cpp
+        test/memory/TScratchAllocatorTest.cpp
     )
 
     SET( cppcore_random_test_src
@@ -163,7 +164,7 @@ IF( CPPCORE_BUILD_UNITTESTS )
     SOURCE_GROUP( code\\container FILES ${cppcore_container_test_src} )
     SOURCE_GROUP( code\\memory    FILES ${cppcore_memory_test_src} ) 
     SOURCE_GROUP( code\\random    FILES ${cppcore_random_test_src} )
-    
+
     # Prevent overriding the parent project's compiler/linker
     # settings on Windows
     SET(gtest_force_shared_crt ON CACHE BOOL "" FORCE)

include/cppcore/IO/FileSystem.h

@@ -49,13 +49,13 @@ class FileSystem {
     /// @brief  The class constructor with the location.
     /// @param[in] location     The root location.
     FileSystem(const char *location);
-    
+
     /// @brief  The class destructor.
     ~FileSystem() = default;
-    
+
     /// @brief  Will perform a refresh.
     void refresh();
-    
+
     /// @brief  Will return the free disk info.
     /// @return the File-system space.
     FSSpace *getFreeDiskSpace();

include/cppcore/Memory/TDefaultAllocator.h

@@ -129,4 +129,4 @@ inline void TDefaultAllocator<T>::dumpAllocations(std::string &allocs) {
     // empty
 }
 
-} // Namespace cppcore
+} // namespace cppcore

include/cppcore/Memory/TPoolAllocator.h

@@ -94,7 +94,7 @@ class TPoolAllocator {
 
     /// @brief  Will reset the allocator.
     void reset();
-    
+
     /// No copying allowed
     CPPCORE_NONE_COPYING(TPoolAllocator)
 

include/cppcore/Memory/TScratchAllocator.h

@@ -0,0 +1,146 @@
+/*-----------------------------------------------------------------------------------------------
+The MIT License (MIT)
+
+Copyright (c) 2014-2024 Kim Kulling
+
+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.
+-----------------------------------------------------------------------------------------------*/
+#pragma once
+
+#include <cppcore/CPPCoreCommon.h>
+
+namespace cppcore {
+
+//-------------------------------------------------------------------------------------------------
+/// @class      TScratchAllocator
+/// @ingroup    CPPCore
+///
+/// @brief A simple scratch allocator.
+///
+/// You can use it to manage all the dynamic allocations without caring about cleaning it up. All
+/// Allocations will be a one-shot alloc, which do not need to get released. When calling clear
+/// all allocation will be invalidated and cannot be used anymore.
+//-------------------------------------------------------------------------------------------------
+template<class T>
+class TScratchAllocator {
+public:
+    /// @brief  The default class constructor.
+    TScratchAllocator();
+
+    /// @brief  The class constructor with the pool size.
+    /// @param[in]  numItems    The buffer size.
+    TScratchAllocator(size_t numItems);
+
+    /// @brief  The class destructor.
+    ~TScratchAllocator();
+
+    /// @brief  Will allocate the number of items.
+    /// @param[in] numItems    The number of items.
+    /// @return Pointr showing to the scratch buffer.
+    T *alloc(size_t numItems);
+
+    /// @brief  Will reserve the pool.
+    /// @apram[in] size    The pool size to reserve.
+    void reserve(size_t size);
+
+    /// @brief  Will clear the pool, memory will be deallocated.
+    /// @note   All instances which are currently is use will get invalid. PLease use with care.
+    void clear();
+
+    /// @brief  Returns the capacity of items in the pool allocator.
+    /// @return The capacity.
+    size_t capacity() const;
+
+    /// @brief  Will return the reserved memory in bytes.
+    /// @return The reserved memory in bytes.
+    size_t reservedMem() const;
+
+    /// @brief  Will return the free memory in the pool in bytes.
+    /// @return The free memory in bytes.
+    size_t freeMem() const;
+
+    /// No copying allowed
+    CPPCORE_NONE_COPYING(TScratchAllocator)
+
+private:
+    T *mBlock;
+    size_t mSize;
+    size_t mIndex;
+};
+
+template<class T>
+inline TScratchAllocator<T>::TScratchAllocator() :
+        mBlock(nullptr), mSize(0u), mIndex(0u) {
+    // empty
+}
+
+template<class T>
+inline TScratchAllocator<T>::TScratchAllocator(size_t numItems) :
+        mBlock(nullptr), mSize(0u), mIndex(0u) {
+    reserve(numItems);
+}
+
+template<class T>
+inline TScratchAllocator<T>::~TScratchAllocator() {
+    clear();
+}
+
+template<class T>
+inline T *TScratchAllocator<T>::alloc(size_t numItems) {
+    if ((mIndex + numItems) > mSize) {
+        return nullptr;
+    }
+
+    T *ptr = &mBlock[mIndex];
+    mIndex += numItems;
+    return ptr;
+}
+
+template<class T>
+void TScratchAllocator<T>::reserve(size_t size) {
+    clear();
+    mBlock = new T[size];
+    mSize = size;
+    mIndex = 0u;
+}
+
+template<class T>
+inline void TScratchAllocator<T>::clear() {
+    delete mBlock;
+    mBlock = nullptr;
+    mSize = 0u;
+}
+
+template<class T>
+inline size_t TScratchAllocator<T>::capacity() const {
+    return mSize;
+}
+
+template<class T>
+size_t TScratchAllocator<T>::reservedMem() const {
+    return mIndex;
+}
+
+template<class T>
+size_t TScratchAllocator<T>::freeMem() const {
+    return (mSize - mIndex);
+}
+
+using ScratchAllocator = TScratchAllocator<char>;
+
+} // namespace cppcore

include/cppcore/Memory/TStackAllocator.h

@@ -185,7 +185,7 @@ inline void TStackAllocator<T>::clear() {
     m_capacity = 0;
     m_top = 0;
 }
-    
+
 template <class T>
 inline void TStackAllocator<T>::reset() {
     m_top = 0;

test/Random/RandomGeneratorTest.cpp

@@ -25,9 +25,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 using namespace cppcore;
 
-class RandomGeneratorTest : public testing::Test {
-    // empty
-};
+class RandomGeneratorTest : public testing::Test {};
 
 TEST_F( RandomGeneratorTest, getTest ) {
     RandomGenerator generator;

test/memory/TScratchAllocatorTest.cpp

@@ -0,0 +1,28 @@
+#include <cppcore/Memory/TScratchAllocator.h>
+
+#include <gtest/gtest.h>
+
+using namespace cppcore;
+
+class TScratchAllocatorTest : public testing::Test {};
+
+TEST_F(TScratchAllocatorTest, CreateTest) {
+    bool ok( true );
+    try {
+        ScratchAllocator myAllocator(1024);
+    } catch ( ... ) {
+        ok = false;
+    }
+    EXPECT_TRUE( ok );
+}
+
+TEST_F(TScratchAllocatorTest, AllocTest) {
+    ScratchAllocator myAllocator(1024);
+    char *ptr1 = myAllocator.alloc(512);
+    EXPECT_NE(ptr1, nullptr);
+    EXPECT_EQ(myAllocator.capacity(), 1024);
+    EXPECT_EQ(myAllocator.freeMem(), 512);
+
+    char *ptr2 = myAllocator.alloc(600);
+    EXPECT_EQ(ptr2, nullptr);
+}

test/memory/TStackAllocatorTest.cpp

@@ -26,9 +26,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 using namespace cppcore;
 
-class TStackAllocatorTest : public testing::Test {
-protected:
-};
+class TStackAllocatorTest : public testing::Test {};
 
 TEST_F( TStackAllocatorTest, CreateTest ) {
     bool ok( true );