Everywhere: De-virtualize IGrowableBuffer destruction

- Avoid virtual call in the destructor used for finalization (mainly null-termination)
- Avoid one more indirection to fetch the virtual table
- Use the entire available capacity when asked

This changes a little bit StringBuilder and SerializationJSON API.

Author: Pagghiu

Documentation/Libraries/Strings.md

@@ -47,6 +47,9 @@ Some relevant blog posts are:
 
 # Definition
 
+## StringBuilder
+@copydoc SC::StringBuilder
+
 ## StringView
 @copydoc SC::StringView
 
@@ -104,21 +107,6 @@ Some relevant blog posts are:
 ### StringViewTokenizer::countTokens
 @copydoc SC::StringViewTokenizer::countTokens
 
-## StringBuilder
-@copydoc SC::StringBuilder
-
-### StringBuilder::format
-@copydoc SC::StringBuilder::format
-
-### StringBuilder::append
-@copydoc SC::StringBuilder::append
-
-### StringBuilder::appendReplaceAll
-@copydoc SC::StringBuilder::appendReplaceAll
-
-### StringBuilder::appendHex
-@copydoc SC::StringBuilder::appendHex
-
 ## StringIterator
 @copydoc SC::StringIterator
 

Examples/SCExample/Examples/SerializationExample/SerializationExample.cpp

@@ -174,9 +174,8 @@ struct SC::SerializationExampleModel
 
     Result saveToJSONFile(StringView jsonPath)
     {
-        Buffer             buffer;
-        StringFormatOutput output(StringEncoding::Ascii, buffer);
-        SC_TRY(SC::SerializationJson::write(modelState, output));
+        Buffer buffer;
+        SC_TRY(SC::SerializationJson::write(modelState, buffer));
         Span<const char> jsonSpan;
         SC_TRY(buffer.toSpanConst().sliceStartLength(0, buffer.size() - 1, jsonSpan));
         return FileSystem().writeString(jsonPath, {jsonSpan, false, StringEncoding::Ascii});

Libraries/Foundation/AlignedStorage.h

@@ -62,8 +62,6 @@ struct AlignedStorage
   private:
     alignas(Alignment) char bytes[N] = {0};
 };
-// Allows using this type across Plugin boundaries
-SC_COMPILER_EXTERN template struct SC_COMPILER_EXPORT AlignedStorage<6 * sizeof(void*)>;
 
 //! @}
 #if SC_COMPILER_GCC

Libraries/Foundation/Internal/IGrowableBuffer.h

@@ -4,47 +4,48 @@
 #include "../../Foundation/PrimitiveTypes.h"
 namespace SC
 {
-/// @brief Virtual interface to abstract a linear binary buffer.
+/// @brief Interface abstracting a linear binary buffer.
 /// It's used by File library to read data into a Buffer or String object without need to know their types.
 /// This allows breaking the dependency between File and Strings / Memory libraries.
 struct SC_COMPILER_EXPORT IGrowableBuffer
 {
+    using TryGrowFunc = bool (*)(IGrowableBuffer& growableBuffer, size_t newSize);
+
     struct DirectAccess
     {
         size_t sizeInBytes     = 0;
         size_t capacityInBytes = 0;
         void*  data            = nullptr;
     };
 
-    /// Note: derived classes should set their size == to match directAccess.sizeInBytes during destructor
-    virtual ~IGrowableBuffer() = default;
+    IGrowableBuffer(TryGrowFunc func) : ptrTryGrowTo(func) {}
 
     [[nodiscard]] bool resizeWithoutInitializing(size_t newSize)
     {
-        if (newSize < directAccess.capacityInBytes) // try to avoid a virtual call
+        if (newSize <= directAccess.capacityInBytes) // try to avoid a virtual call
         {
             directAccess.sizeInBytes = newSize; // size on type erased buffer will be set by virtual destructor
             return true;
         }
-        return tryGrowTo(newSize);
+        return ptrTryGrowTo(*this, newSize);
     }
+
     void   clear() { directAccess.sizeInBytes = 0; }
     char*  data() const { return static_cast<char*>(directAccess.data); }
     size_t size() const { return directAccess.sizeInBytes; }
-
-    DirectAccess getDirectAccess() const { return directAccess; }
+    auto   getDirectAccess() const { return directAccess; }
 
   protected:
-    /// @brief  Try to grow the buffer to a new size, and update directAccess.
-    /// @param newSize The desired new size for the buffer.
-    /// @return `true` if the buffer was successfully grown, `false` otherwise.
-    [[nodiscard]] virtual bool tryGrowTo(size_t newSize) = 0;
-
+    TryGrowFunc  ptrTryGrowTo;
     DirectAccess directAccess;
 };
 
 /// @brief Partial specialize GrowableBuffer deriving from IGrowableBuffer (see how String and Buffer do it)
 template <typename T>
-struct GrowableBuffer;
+struct GrowableBuffer
+{
+    T& content;
+    GrowableBuffer(T& content) : content(content) {}
+};
 
 } // namespace SC

Libraries/Foundation/Internal/StringPath.inl

@@ -2,21 +2,25 @@
 // SPDX-License-Identifier: MIT
 #include "../../Foundation/StringPath.h"
 
-SC::GrowableBuffer<SC::StringPath>::GrowableBuffer(StringPath& string) : sp(string)
+SC::GrowableBuffer<SC::StringPath>::GrowableBuffer(StringPath& string) noexcept
+    : IGrowableBuffer(&GrowableBuffer::tryGrowTo), sp(string)
 {
     directAccess = {sp.view().sizeInBytes(), (StringPath::MaxPath - 1) * sizeof(native_char_t),
                     sp.writableSpan().data()};
 }
 
-SC::GrowableBuffer<SC::StringPath>::~GrowableBuffer()
+SC::GrowableBuffer<SC::StringPath>::~GrowableBuffer() noexcept { finalize(); }
+
+void SC::GrowableBuffer<SC::StringPath>::finalize() noexcept
 {
     (void)sp.resize(directAccess.sizeInBytes / sizeof(native_char_t));
 }
 
-bool SC::GrowableBuffer<SC::StringPath>::tryGrowTo(size_t newSize)
+bool SC::GrowableBuffer<SC::StringPath>::tryGrowTo(IGrowableBuffer& gb, size_t newSize) noexcept
 {
-    const bool res           = sp.resize(newSize / sizeof(native_char_t));
-    directAccess.sizeInBytes = sp.view().sizeInBytes();
+    GrowableBuffer& self          = static_cast<GrowableBuffer&>(gb);
+    const bool      res           = self.sp.resize(newSize / sizeof(native_char_t));
+    self.directAccess.sizeInBytes = self.sp.view().sizeInBytes();
     return res;
 }
 

Libraries/Foundation/StringPath.h

@@ -63,12 +63,13 @@ struct SC_COMPILER_EXPORT StringPath
 };
 
 template <>
-struct SC_COMPILER_EXPORT GrowableBuffer<StringPath> final : public IGrowableBuffer
+struct SC_COMPILER_EXPORT GrowableBuffer<StringPath> : public IGrowableBuffer
 {
     StringPath& sp;
-    GrowableBuffer(StringPath& string);
-    virtual ~GrowableBuffer() override;
-    virtual bool tryGrowTo(size_t newSize) override;
-    static auto  getEncodingFor(const StringPath& sp) { return sp.getEncoding(); }
+    GrowableBuffer(StringPath& string) noexcept;
+    ~GrowableBuffer() noexcept;
+    static bool tryGrowTo(IGrowableBuffer& gb, size_t newSize) noexcept;
+    static auto getEncodingFor(const StringPath& sp) noexcept { return sp.getEncoding(); }
+    void        finalize() noexcept;
 };
 } // namespace SC

Libraries/Memory/Buffer.h

@@ -68,29 +68,33 @@ struct SC_COMPILER_EXPORT Buffer;
 
 // Enables File library from reading data from file descriptor into a Buffer
 template <>
-struct SC_COMPILER_EXPORT GrowableBuffer<Buffer> final : public IGrowableBuffer
+struct SC_COMPILER_EXPORT GrowableBuffer<Buffer> : public IGrowableBuffer
 {
     Buffer& buffer;
-    GrowableBuffer(Buffer& buffer);
-    ~GrowableBuffer();
-    virtual bool tryGrowTo(size_t newSize) override;
+    GrowableBuffer(Buffer& buffer) noexcept;
+    ~GrowableBuffer() noexcept;
+    static bool tryGrowTo(IGrowableBuffer&, size_t newSize) noexcept;
+    void        finalize() noexcept;
 };
 
 template <int N>
-struct SC_COMPILER_EXPORT GrowableBuffer<SmallBuffer<N>> final : public IGrowableBuffer
+struct SC_COMPILER_EXPORT GrowableBuffer<SmallBuffer<N>> : public IGrowableBuffer
 {
     Buffer& buffer;
-    GrowableBuffer(Buffer& buffer) : buffer(buffer)
+    GrowableBuffer(Buffer& buffer) noexcept : IGrowableBuffer(&GrowableBuffer::tryGrowTo), buffer(buffer)
     {
         IGrowableBuffer::directAccess = {buffer.size(), buffer.capacity(), buffer.data()};
     }
-    ~GrowableBuffer() { (void)buffer.resizeWithoutInitializing(IGrowableBuffer::directAccess.sizeInBytes); }
-    virtual bool tryGrowTo(size_t newSize) override
+    ~GrowableBuffer() noexcept { finalize(); }
+
+    static bool tryGrowTo(IGrowableBuffer& gb, size_t newSize) noexcept
     {
-        const bool result             = buffer.resizeWithoutInitializing(newSize);
-        IGrowableBuffer::directAccess = {buffer.size(), buffer.capacity(), buffer.data()};
+        GrowableBuffer& self   = static_cast<GrowableBuffer&>(gb);
+        const bool      result = self.buffer.resizeWithoutInitializing(newSize);
+        self.directAccess      = {self.buffer.size(), self.buffer.capacity(), self.buffer.data()};
         return result;
     }
+    void finalize() noexcept { (void)buffer.resizeWithoutInitializing(IGrowableBuffer::directAccess.sizeInBytes); }
 };
 //! @}
 } // namespace SC

Libraries/Memory/Internal/Buffer.inl

@@ -11,25 +11,29 @@ template struct Segment<detail::SegmentBuffer>;
 template bool Segment<detail::SegmentBuffer>::assign<char>(Span<const char>) noexcept;
 template bool Segment<detail::SegmentBuffer>::append<char>(Span<const char>) noexcept;
 
-GrowableBuffer<Buffer>::GrowableBuffer(Buffer& buffer) : buffer(buffer)
+GrowableBuffer<Buffer>::GrowableBuffer(Buffer& buffer) noexcept
+    : IGrowableBuffer(&GrowableBuffer::tryGrowTo), buffer(buffer)
 {
     IGrowableBuffer::directAccess = {buffer.size(), buffer.capacity(), buffer.data()};
 }
 
-GrowableBuffer<Buffer>::~GrowableBuffer()
+GrowableBuffer<Buffer>::~GrowableBuffer() noexcept { finalize(); }
+
+void GrowableBuffer<Buffer>::finalize() noexcept
 {
     if (buffer.size() != IGrowableBuffer::directAccess.sizeInBytes)
     {
         (void)buffer.resizeWithoutInitializing(IGrowableBuffer::directAccess.sizeInBytes);
     }
 }
 
-bool GrowableBuffer<Buffer>::tryGrowTo(size_t newSize)
+bool GrowableBuffer<Buffer>::tryGrowTo(IGrowableBuffer& gb, size_t newSize) noexcept
 {
+    GrowableBuffer& self = static_cast<GrowableBuffer&>(gb);
     // ensure size is correct before trying to grow to avoid losing data
-    (void)buffer.resizeWithoutInitializing(IGrowableBuffer::directAccess.sizeInBytes);
-    const bool result             = buffer.resizeWithoutInitializing(newSize);
-    IGrowableBuffer::directAccess = {buffer.size(), buffer.capacity(), buffer.data()};
+    (void)self.buffer.resizeWithoutInitializing(self.directAccess.sizeInBytes);
+    const bool result = self.buffer.resizeWithoutInitializing(newSize);
+    self.directAccess = {self.buffer.size(), self.buffer.capacity(), self.buffer.data()};
     return result;
 }
 

Libraries/Memory/Internal/String.inl

@@ -78,15 +78,17 @@ SC::StringSpan SC::String::view() const SC_LANGUAGE_LIFETIME_BOUND
     return StringSpan({items, isEmpty ? 0 : data.size() - StringEncodingGetSize(encoding)}, not isEmpty, encoding);
 }
 
-SC::String::GrowableImplementation::GrowableImplementation(String& string, IGrowableBuffer::DirectAccess& da)
+SC::String::GrowableImplementation::GrowableImplementation(String& string, IGrowableBuffer::DirectAccess& da) noexcept
     : string(string), da(da)
 {
     const size_t numZeros = StringEncodingGetSize(string.getEncoding());
     da                    = {string.data.isEmpty() ? 0 : string.data.size() - numZeros,
           string.data.capacity() > numZeros ? string.data.capacity() - numZeros : 0, string.data.data()};
 }
 
-SC::String::GrowableImplementation::~GrowableImplementation()
+SC::String::GrowableImplementation::~GrowableImplementation() noexcept { finalize(); }
+
+void SC::String::GrowableImplementation::finalize() noexcept
 {
     const size_t numZeros = StringEncodingGetSize(string.getEncoding());
     if (da.sizeInBytes == 0)
@@ -103,7 +105,7 @@ SC::String::GrowableImplementation::~GrowableImplementation()
     }
 }
 
-bool SC::String::GrowableImplementation::tryGrowTo(size_t newSize)
+bool SC::String::GrowableImplementation::tryGrowTo(size_t newSize) noexcept
 {
     // ensure size is correct before trying to grow to avoid losing data
     (void)string.data.resizeWithoutInitializing(da.sizeInBytes);

Libraries/Memory/String.h

@@ -156,9 +156,10 @@ struct SC::String
 
         IGrowableBuffer::DirectAccess& da;
 
-        GrowableImplementation(String& string, IGrowableBuffer::DirectAccess& da);
-        ~GrowableImplementation();
-        bool tryGrowTo(size_t newSize);
+        GrowableImplementation(String& string, IGrowableBuffer::DirectAccess& da) noexcept;
+        ~GrowableImplementation() noexcept;
+        void finalize() noexcept;
+        bool tryGrowTo(size_t newSize) noexcept;
     };
 
     StringEncoding encoding;
@@ -208,20 +209,32 @@ SC_COMPILER_EXTERN template struct SC_COMPILER_EXPORT SmallString<1024 * sizeof(
 
 // Enables File library from reading data from file descriptor into a String
 template <>
-struct SC_COMPILER_EXPORT GrowableBuffer<String> final : public IGrowableBuffer
+struct SC_COMPILER_EXPORT GrowableBuffer<String> : public IGrowableBuffer
 {
     String::GrowableImplementation gi;
-    GrowableBuffer(String& string) : gi(string, IGrowableBuffer::directAccess) {}
-    virtual bool tryGrowTo(size_t newSize) override { return gi.tryGrowTo(newSize); }
-    static auto  getEncodingFor(const String& str) { return str.getEncoding(); }
+    GrowableBuffer(String& string)
+        : IGrowableBuffer(&GrowableBuffer::tryGrowTo), gi(string, IGrowableBuffer::directAccess)
+    {}
+    static bool tryGrowTo(IGrowableBuffer& gb, size_t newSize) noexcept
+    {
+        return static_cast<GrowableBuffer&>(gb).gi.tryGrowTo(newSize);
+    }
+    static auto getEncodingFor(const String& str) noexcept { return str.getEncoding(); }
+    void        finalize() noexcept { gi.finalize(); }
 };
 
 template <int N>
-struct SC_COMPILER_EXPORT GrowableBuffer<SmallString<N>> final : public IGrowableBuffer
+struct SC_COMPILER_EXPORT GrowableBuffer<SmallString<N>> : public IGrowableBuffer
 {
     String::GrowableImplementation gi;
-    GrowableBuffer(String& string) : gi(string, IGrowableBuffer::directAccess) {}
-    virtual bool tryGrowTo(size_t newSize) override { return gi.tryGrowTo(newSize); }
-    static auto  getEncodingFor(const SmallString<N>& str) { return str.getEncoding(); }
+    GrowableBuffer(String& string)
+        : IGrowableBuffer(&GrowableBuffer::tryGrowTo), gi(string, IGrowableBuffer::directAccess)
+    {}
+    static bool tryGrowTo(IGrowableBuffer& gb, size_t newSize) noexcept
+    {
+        return static_cast<GrowableBuffer&>(gb).gi.tryGrowTo(newSize);
+    }
+    static auto getEncodingFor(const SmallString<N>& str) noexcept { return str.getEncoding(); }
+    void        finalize() noexcept { gi.finalize(); }
 };
 } // namespace SC