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,19 @@
+// 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 StringPtr *string_pool_new_assign(const char *str);
+    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,104 @@
+// 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;
+
+std::unordered_set<std::unique_ptr<StringPtr>> strings;
+std::multimap<size_t, StringPtr *> freeStrings; // sorted by allocated space
+
+std::unordered_map<Thread *, std::unordered_set<StringPtr *>> threadStrings;
+Thread *currentThread = nullptr;
+
+extern "C"
+{
+    /*! Use this instead of dynamically allocating StringPtr. */
+    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);
+        ptr->size = 0;
+
+        if (ptr->allocatedSize > 0)
+            ptr->data[0] = u'\0';
+
+        if (currentThread)
+            threadStrings[currentThread].insert(ptr);
+
+        return ptr;
+    }
+
+    /*! Calls string_pool_new() and assigns the given string. */
+    StringPtr *string_pool_new_assign(const char *str)
+    {
+        StringPtr *ret = string_pool_new();
+        string_assign_cstring(ret, str);
+        return ret;
+    }
+
+    /*! 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