Add string pool

Author: adazem009

CMakeLists.txt

@@ -40,6 +40,7 @@ target_sources(scratchcpp
     include/scratchcpp/value_functions.h
     include/scratchcpp/stringptr.h
     include/scratchcpp/string_functions.h
+    include/scratchcpp/string_pool.h
     include/scratchcpp/entity.h
     include/scratchcpp/variable.h
     include/scratchcpp/list.h

include/scratchcpp/string_pool.h

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "global.h"
+
+namespace libscratchcpp
+{
+
+struct StringPtr;
+
+extern "C"
+{
+    LIBSCRATCHCPP_EXPORT StringPtr *string_pool_new();
+    LIBSCRATCHCPP_EXPORT void string_pool_free(StringPtr *str);
+}
+
+} // namespace libscratchcpp

src/scratch/CMakeLists.txt

@@ -3,6 +3,8 @@ target_sources(scratchcpp
     value_functions.cpp
     value_functions_p.h
     string_functions.cpp
+    string_pool.cpp
+    string_pool_p.h
     drawable.cpp
     drawable_p.cpp
     drawable_p.h

src/scratch/string_pool.cpp

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include <scratchcpp/string_pool.h>
+#include <scratchcpp/stringptr.h>
+#include <scratchcpp/string_functions.h>
+#include <memory>
+#include <unordered_set>
+#include <unordered_map>
+#include <map>
+#include <cassert>
+
+namespace libscratchcpp
+{
+
+class Thread;
+
+static std::unordered_set<std::unique_ptr<StringPtr>> strings;
+static std::multimap<size_t, StringPtr *> freeStrings; // sorted by allocated space
+
+static std::unordered_map<Thread *, std::unordered_set<StringPtr *>> threadStrings;
+static Thread *currentThread = nullptr;
+
+extern "C"
+{
+    /*!
+     * Use this instead of dynamically allocating StringPtr.
+     * \note The returned string is uninitialized. Use e. g. string_assign_cstring() to initialize it.
+     */
+    StringPtr *string_pool_new()
+    {
+        if (freeStrings.empty()) {
+            auto str = std::make_unique<StringPtr>();
+            StringPtr *ptr = str.get();
+            assert(strings.find(str) == strings.cend());
+            strings.insert(std::move(str));
+
+            if (currentThread)
+                threadStrings[currentThread].insert(ptr);
+
+            return ptr;
+        }
+
+        // Optimization: pick string with the highest capacity to minimize allocs
+        auto last = std::prev(freeStrings.end());
+        StringPtr *ptr = last->second;
+        freeStrings.erase(last);
+
+        if (currentThread)
+            threadStrings[currentThread].insert(ptr);
+
+        return ptr;
+    }
+
+    /*! Invalidates the given StringPtr so that it can be used for new strings later. */
+    void string_pool_free(StringPtr *str)
+    {
+        if (currentThread) {
+            assert(threadStrings[currentThread].find(str) != threadStrings[currentThread].cend());
+            threadStrings[currentThread].erase(str);
+        }
+
+        freeStrings.insert(std::pair<size_t, StringPtr *>(str->allocatedSize, str));
+    }
+}
+
+/* string_pool_p.h */
+
+void string_pool_add_thread(Thread *thread)
+{
+    // Start capturing allocated strings in the thread
+    assert(threadStrings.find(thread) == threadStrings.cend());
+    threadStrings[thread] = {};
+}
+
+void string_pool_remove_thread(Thread *thread)
+{
+    // Free all strings in the thread (garbage collection)
+    assert(threadStrings.find(thread) != threadStrings.cend());
+    auto &strings = threadStrings[thread];
+
+    for (StringPtr *str : strings)
+        freeStrings.insert(std::pair<size_t, StringPtr *>(str->allocatedSize, str));
+
+    strings.clear();
+
+    if (currentThread == thread)
+        currentThread = nullptr;
+}
+
+void string_pool_set_thread(Thread *thread)
+{
+    currentThread = thread;
+}
+
+} // namespace libscratchcpp

src/scratch/string_pool_p.h

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: Apache-2.0
+
+namespace libscratchcpp
+{
+
+class Thread;
+
+void string_pool_add_thread(Thread *thread);
+void string_pool_remove_thread(Thread *thread);
+void string_pool_set_thread(Thread *thread);
+
+} // namespace libscratchcpp

test/scratch_classes/CMakeLists.txt

@@ -135,6 +135,20 @@ target_link_libraries(
 
 gtest_discover_tests(string_functions_test)
 
+# string_pool_test
+add_executable(
+  string_pool_test
+  string_pool_test.cpp
+)
+
+target_link_libraries(
+  string_pool_test
+  GTest::gtest_main
+  scratchcpp
+)
+
+gtest_discover_tests(string_pool_test)
+
 # entity_test
 add_executable(
   entity_test

test/scratch_classes/string_pool_test.cpp

@@ -0,0 +1,30 @@
+#include <scratchcpp/string_pool.h>
+#include <scratchcpp/string_functions.h>
+#include <scratchcpp/stringptr.h>
+
+#include "../common.h"
+
+using namespace libscratchcpp;
+
+TEST(StringPoolTest, NewAndFree)
+{
+    StringPtr *str1 = string_pool_new();
+    ASSERT_TRUE(str1);
+    string_assign_cstring(str1, "test");
+    ASSERT_EQ(str1->size, 4);
+
+    StringPtr *str2 = string_pool_new();
+    ASSERT_TRUE(str2);
+    string_assign_cstring(str2, "Lorem ipsum dolor sit amet");
+    ASSERT_EQ(str2->size, 26);
+
+    string_pool_free(str1);
+    string_pool_free(str2);
+
+    StringPtr *str3 = string_pool_new();
+    ASSERT_TRUE(str3);
+    string_assign_cstring(str3, "Hello world");
+    ASSERT_EQ(str3->size, 11);
+
+    // str3 will be deallocated later
+}