Optimisation

a1q123456 · a1q123456 · commit 436c4f22fe2d · 2025-09-02T17:41:00.000+01:00
Signed-off-by: JCW &lt;a1q123456@users.noreply.github.com&gt;
diff --git a/include/xrpl/beast/utility/Journal.h b/include/xrpl/beast/utility/Journal.h
@@ -80,46 +80,44 @@ namespace beast {
 class SimpleJsonWriter
 {
 public:
-    explicit SimpleJsonWriter(std::ostringstream& stream) : stream_(stream)
+    explicit SimpleJsonWriter(std::string& stream) : stream_(stream)
     {
-        stream_.imbue(std::locale::classic());
     }
 
     void
     startObject() const
     {
-        stream_.put('{');
+        stream_.append("{", 1);
     }
     void
     endObject() const
     {
-        stream_.seekp(-1, std::ios_base::end);
-        stream_.write("},", 2);
+        stream_.pop_back();
+        stream_.append("},", 2);
     }
     void
     writeKey(std::string_view key) const
     {
         writeString(key);
-        stream_.seekp(-1, std::ios_base::end);
-        stream_.put(':');
+        *stream_.rbegin() = ':';
     }
     void
     startArray() const
     {
-        stream_.put('[');
+        stream_.append("[", 1);
     }
     void
     endArray() const
     {
-        stream_.seekp(-1, std::ios_base::end);
-        stream_.write("],", 2);
+        stream_.pop_back();
+        stream_.append("],", 2);
     }
     void
     writeString(std::string_view str) const
     {
-        stream_.put('"');
+        stream_.push_back('"');
         escape(str, stream_);
-        stream_.write("\",", 2);
+        stream_.append("\",", 2);
     }
     std::string_view
     writeInt(std::int64_t val) const
@@ -140,44 +138,43 @@ class SimpleJsonWriter
     writeBool(bool val) const
     {
         auto str = val ? "true," : "false,";
-        stream_.write(str, std::strlen(str));
+        stream_.append(str, std::strlen(str));
         return str;
     }
     void
     writeNull() const
     {
-        stream_.write("null", std::strlen("null"));
-        stream_.put(',');
+        stream_.append("null", std::strlen("null"));
+        stream_.push_back(',');
     }
     void
     writeRaw(std::string_view str) const
     {
-        stream_.write(str.data(), str.length());
+        stream_.append(str);
     }
 
     [[nodiscard]] std::string
-    str() const
+    finish()
     {
-        auto result = stream_.str();
-        result.pop_back();
-        return result;
+        stream_.pop_back();
+        return stream_;
     }
 
 private:
     template <typename T>
     static std::string_view
-    pushNumber(T val, std::ostringstream& stream)
+    pushNumber(T val, std::string& stream)
     {
         static char buffer[128];
         auto result = std::to_chars(std::begin(buffer), std::end(buffer), val);
         *result.ptr = ',';
         auto len = result.ptr - std::begin(buffer);
-        stream.write(buffer, len + 1);
+        stream.append(buffer, len + 1);
         return {buffer, static_cast<size_t>(len)};
     }
 
     static void
-    escape(std::string_view str, std::ostringstream& os)
+    escape(std::string_view str, std::string& os)
     {
         static constexpr char HEX[] = "0123456789ABCDEF";
 
@@ -198,24 +195,24 @@ class SimpleJsonWriter
 
             // Flush the preceding safe run in one go.
             if (chunk != p)
-                os.write(chunk, p - chunk);
+                os.append(chunk, p - chunk);
 
             switch (c) {
-                case '"':  os.write("\\\"", 2); break;
-                case '\\': os.write("\\\\", 2); break;
-                case '\b': os.write("\\b",  2); break;
-                case '\f': os.write("\\f",  2); break;
-                case '\n': os.write("\\n",  2); break;
-                case '\r': os.write("\\r",  2); break;
-                case '\t': os.write("\\t",  2); break;
+                case '"':  os.append("\\\"", 2); break;
+                case '\\': os.append("\\\\", 2); break;
+                case '\b': os.append("\\b",  2); break;
+                case '\f': os.append("\\f",  2); break;
+                case '\n': os.append("\\n",  2); break;
+                case '\r': os.append("\\r",  2); break;
+                case '\t': os.append("\\t",  2); break;
                 default: {
                     // Other C0 controls -> \u00XX (JSON compliant)
                     char buf[6]{
                         '\\','u','0','0',
                         HEX[(c >> 4) & 0xF],
                         HEX[c & 0xF]
                     };
-                    os.write(buf, 6);
+                    os.append(buf, 6);
                     break;
                 }
             }
@@ -226,10 +223,10 @@ class SimpleJsonWriter
 
         // Flush trailing safe run
         if (chunk != p)
-            os.write(chunk, p - chunk);
+            os.append(chunk, p - chunk);
     }
 
-    std::ostringstream& stream_;
+    std::string& stream_;
 };
 
 /** A namespace for easy access to logging severity values. */
@@ -284,7 +281,7 @@ class Journal
 
     class JsonLogContext
     {
-        std::ostringstream buffer_;
+        std::string buffer_;
         SimpleJsonWriter messageParamsWriter_;
 
     public:
@@ -567,14 +564,14 @@ class Journal
     Journal(Journal const& other, TAttributesFactory&& attributesFactory)
         : m_name(other.m_name), m_sink(other.m_sink)
     {
-        std::ostringstream stream{other.m_attributesJson, std::ios_base::app};
+        std::string stream{other.m_attributesJson};
         SimpleJsonWriter writer{stream};
         if (other.m_attributesJson.empty())
         {
             writer.startObject();
         }
         attributesFactory(writer);
-        m_attributesJson = stream.str();
+        m_attributesJson = std::move(stream);
     }
 
     /** Create a journal that writes to the specified sink. */
@@ -591,11 +588,11 @@ class Journal
         TAttributesFactory&& attributesFactory)
         : m_name(name), m_sink(&sink)
     {
-        std::ostringstream stream;
+        std::string stream;
         SimpleJsonWriter writer{stream};
         writer.startObject();
         attributesFactory(writer);
-        m_attributesJson = stream.str();
+        m_attributesJson = std::move(stream);
     }
 
     Journal&
@@ -712,15 +709,14 @@ class Journal
         std::lock_guard lock(globalLogAttributesMutex_);
 
         auto isEmpty = globalLogAttributesJson_.empty();
-        std::ostringstream stream{
-            std::move(globalLogAttributesJson_), std::ios_base::app};
+        std::string stream{std::move(globalLogAttributesJson_)};
         SimpleJsonWriter writer{stream};
         if (isEmpty)
         {
             writer.startObject();
         }
         factory(writer);
-        globalLogAttributesJson_ = stream.str();
+        globalLogAttributesJson_ = std::move(stream);
     }
 };
 
diff --git a/src/libxrpl/beast/utility/beast_Journal.cpp b/src/libxrpl/beast/utility/beast_Journal.cpp
@@ -138,7 +138,7 @@ Journal::JsonLogContext::reset(
     };
     thread_local ThreadIdStringInitializer const threadId;
 
-    buffer_.str("");
+    buffer_.clear();
 
     writer().startObject();
 
@@ -206,7 +206,7 @@ Journal::formatLog(std::string&& message)
 
     writer.endObject();
 
-    return writer.str();
+    return writer.finish();
 }
 
 void
diff --git a/src/tests/libxrpl/basics/log.cpp b/src/tests/libxrpl/basics/log.cpp
@@ -212,35 +212,35 @@ TEST_CASE("Global attributes inheritable")
 TEST_CASE("Test JsonWriter")
 {
     {
-        std::ostringstream stream;
+        std::string stream;
         beast::SimpleJsonWriter writer{stream};
 
         writer.writeString("\n");
-        CHECK(writer.str() == "\"\\n\"");
+        CHECK(writer.finish() == "\"\\n\"");
     }
 
     {
-        std::ostringstream stream;
+        std::string stream;
         beast::SimpleJsonWriter writer{stream};
 
         writer.writeString("\t");
-        CHECK(writer.str() == "\"\\t\"");
+        CHECK(writer.finish() == "\"\\t\"");
     }
 
     {
-        std::ostringstream stream;
+        std::string stream;
         beast::SimpleJsonWriter writer{stream};
 
         writer.writeString(std::string_view{"\0", 1});
-        CHECK(writer.str() == "\"\\u0000\"");
+        CHECK(writer.finish() == "\"\\u0000\"");
     }
 
     {
-        std::ostringstream stream;
+        std::string stream;
         beast::SimpleJsonWriter writer{stream};
 
         writer.writeString("\"\\");
-        CHECK(writer.str() == "\"\\\"\\\\\"");
+        CHECK(writer.finish() == "\"\\\"\\\\\"");
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -80,46 +80,44 @@ namespace beast {`
`80`	`80`	`class SimpleJsonWriter`
`81`	`81`	`{`
`82`	`82`	`public:`
`83`		`- explicit SimpleJsonWriter(std::ostringstream& stream) : stream_(stream)`
	`83`	`+ explicit SimpleJsonWriter(std::string& stream) : stream_(stream)`
`84`	`84`	`{`
`85`		`- stream_.imbue(std::locale::classic());`
`86`	`85`	`}`
`87`	`86`
`88`	`87`	`void`
`89`	`88`	`startObject() const`
`90`	`89`	`{`
`91`		`- stream_.put('{');`
	`90`	`+ stream_.append("{", 1);`
`92`	`91`	`}`
`93`	`92`	`void`
`94`	`93`	`endObject() const`
`95`	`94`	`{`
`96`		`- stream_.seekp(-1, std::ios_base::end);`
`97`		`- stream_.write("},", 2);`
	`95`	`+ stream_.pop_back();`
	`96`	`+ stream_.append("},", 2);`
`98`	`97`	`}`
`99`	`98`	`void`
`100`	`99`	`writeKey(std::string_view key) const`
`101`	`100`	`{`
`102`	`101`	`writeString(key);`
`103`		`- stream_.seekp(-1, std::ios_base::end);`
`104`		`- stream_.put(':');`
	`102`	`+ *stream_.rbegin() = ':';`
`105`	`103`	`}`
`106`	`104`	`void`
`107`	`105`	`startArray() const`
`108`	`106`	`{`
`109`		`- stream_.put('[');`
	`107`	`+ stream_.append("[", 1);`
`110`	`108`	`}`
`111`	`109`	`void`
`112`	`110`	`endArray() const`
`113`	`111`	`{`
`114`		`- stream_.seekp(-1, std::ios_base::end);`
`115`		`- stream_.write("],", 2);`
	`112`	`+ stream_.pop_back();`
	`113`	`+ stream_.append("],", 2);`
`116`	`114`	`}`
`117`	`115`	`void`
`118`	`116`	`writeString(std::string_view str) const`
`119`	`117`	`{`
`120`		`- stream_.put('"');`
	`118`	`+ stream_.push_back('"');`
`121`	`119`	`escape(str, stream_);`
`122`		`- stream_.write("\",", 2);`
	`120`	`+ stream_.append("\",", 2);`
`123`	`121`	`}`
`124`	`122`	`std::string_view`
`125`	`123`	`writeInt(std::int64_t val) const`
`@@ -140,44 +138,43 @@ class SimpleJsonWriter`
`140`	`138`	`writeBool(bool val) const`
`141`	`139`	`{`
`142`	`140`	`auto str = val ? "true," : "false,";`
`143`		`- stream_.write(str, std::strlen(str));`
	`141`	`+ stream_.append(str, std::strlen(str));`
`144`	`142`	`return str;`
`145`	`143`	`}`
`146`	`144`	`void`
`147`	`145`	`writeNull() const`
`148`	`146`	`{`
`149`		`- stream_.write("null", std::strlen("null"));`
`150`		`- stream_.put(',');`
	`147`	`+ stream_.append("null", std::strlen("null"));`
	`148`	`+ stream_.push_back(',');`
`151`	`149`	`}`
`152`	`150`	`void`
`153`	`151`	`writeRaw(std::string_view str) const`
`154`	`152`	`{`
`155`		`- stream_.write(str.data(), str.length());`
	`153`	`+ stream_.append(str);`
`156`	`154`	`}`
`157`	`155`
`158`	`156`	`[[nodiscard]] std::string`
`159`		`- str() const`
	`157`	`+ finish()`
`160`	`158`	`{`
`161`		`- auto result = stream_.str();`
`162`		`- result.pop_back();`
`163`		`- return result;`
	`159`	`+ stream_.pop_back();`
	`160`	`+ return stream_;`
`164`	`161`	`}`
`165`	`162`
`166`	`163`	`private:`
`167`	`164`	`template <typename T>`
`168`	`165`	`static std::string_view`
`169`		`- pushNumber(T val, std::ostringstream& stream)`
	`166`	`+ pushNumber(T val, std::string& stream)`
`170`	`167`	`{`
`171`	`168`	`static char buffer[128];`
`172`	`169`	`auto result = std::to_chars(std::begin(buffer), std::end(buffer), val);`
`173`	`170`	`*result.ptr = ',';`
`174`	`171`	`auto len = result.ptr - std::begin(buffer);`
`175`		`- stream.write(buffer, len + 1);`
	`172`	`+ stream.append(buffer, len + 1);`
`176`	`173`	`return {buffer, static_cast<size_t>(len)};`
`177`	`174`	`}`
`178`	`175`
`179`	`176`	`static void`
`180`		`- escape(std::string_view str, std::ostringstream& os)`
	`177`	`+ escape(std::string_view str, std::string& os)`
`181`	`178`	`{`
`182`	`179`	`static constexpr char HEX[] = "0123456789ABCDEF";`
`183`	`180`
`@@ -198,24 +195,24 @@ class SimpleJsonWriter`
`198`	`195`
`199`	`196`	`// Flush the preceding safe run in one go.`
`200`	`197`	`if (chunk != p)`
`201`		`- os.write(chunk, p - chunk);`
	`198`	`+ os.append(chunk, p - chunk);`
`202`	`199`
`203`	`200`	`switch (c) {`
`204`		`- case '"': os.write("\\\"", 2); break;`
`205`		`- case '\\': os.write("\\\\", 2); break;`
`206`		`- case '\b': os.write("\\b", 2); break;`
`207`		`- case '\f': os.write("\\f", 2); break;`
`208`		`- case '\n': os.write("\\n", 2); break;`
`209`		`- case '\r': os.write("\\r", 2); break;`
`210`		`- case '\t': os.write("\\t", 2); break;`
	`201`	`+ case '"': os.append("\\\"", 2); break;`
	`202`	`+ case '\\': os.append("\\\\", 2); break;`
	`203`	`+ case '\b': os.append("\\b", 2); break;`
	`204`	`+ case '\f': os.append("\\f", 2); break;`
	`205`	`+ case '\n': os.append("\\n", 2); break;`
	`206`	`+ case '\r': os.append("\\r", 2); break;`
	`207`	`+ case '\t': os.append("\\t", 2); break;`
`211`	`208`	`default: {`
`212`	`209`	`// Other C0 controls -> \u00XX (JSON compliant)`
`213`	`210`	`char buf[6]{`
`214`	`211`	`'\\','u','0','0',`
`215`	`212`	`HEX[(c >> 4) & 0xF],`
`216`	`213`	`HEX[c & 0xF]`
`217`	`214`	`};`
`218`		`- os.write(buf, 6);`
	`215`	`+ os.append(buf, 6);`
`219`	`216`	`break;`
`220`	`217`	`}`
`221`	`218`	`}`
`@@ -226,10 +223,10 @@ class SimpleJsonWriter`
`226`	`223`
`227`	`224`	`// Flush trailing safe run`
`228`	`225`	`if (chunk != p)`
`229`		`- os.write(chunk, p - chunk);`
	`226`	`+ os.append(chunk, p - chunk);`
`230`	`227`	`}`
`231`	`228`
`232`		`- std::ostringstream& stream_;`
	`229`	`+ std::string& stream_;`
`233`	`230`	`};`
`234`	`231`
`235`	`232`	`/** A namespace for easy access to logging severity values. */`
`@@ -284,7 +281,7 @@ class Journal`
`284`	`281`
`285`	`282`	`class JsonLogContext`
`286`	`283`	`{`
`287`		`- std::ostringstream buffer_;`
	`284`	`+ std::string buffer_;`
`288`	`285`	`SimpleJsonWriter messageParamsWriter_;`
`289`	`286`
`290`	`287`	`public:`
`@@ -567,14 +564,14 @@ class Journal`
`567`	`564`	`Journal(Journal const& other, TAttributesFactory&& attributesFactory)`
`568`	`565`	`: m_name(other.m_name), m_sink(other.m_sink)`
`569`	`566`	`{`
`570`		`- std::ostringstream stream{other.m_attributesJson, std::ios_base::app};`
	`567`	`+ std::string stream{other.m_attributesJson};`
`571`	`568`	`SimpleJsonWriter writer{stream};`
`572`	`569`	`if (other.m_attributesJson.empty())`
`573`	`570`	`{`
`574`	`571`	`writer.startObject();`
`575`	`572`	`}`
`576`	`573`	`attributesFactory(writer);`
`577`		`- m_attributesJson = stream.str();`
	`574`	`+ m_attributesJson = std::move(stream);`
`578`	`575`	`}`
`579`	`576`
`580`	`577`	`/** Create a journal that writes to the specified sink. */`
`@@ -591,11 +588,11 @@ class Journal`
`591`	`588`	`TAttributesFactory&& attributesFactory)`
`592`	`589`	`: m_name(name), m_sink(&sink)`
`593`	`590`	`{`
`594`		`- std::ostringstream stream;`
	`591`	`+ std::string stream;`
`595`	`592`	`SimpleJsonWriter writer{stream};`
`596`	`593`	`writer.startObject();`
`597`	`594`	`attributesFactory(writer);`
`598`		`- m_attributesJson = stream.str();`
	`595`	`+ m_attributesJson = std::move(stream);`
`599`	`596`	`}`
`600`	`597`
`601`	`598`	`Journal&`
`@@ -712,15 +709,14 @@ class Journal`
`712`	`709`	`std::lock_guard lock(globalLogAttributesMutex_);`
`713`	`710`
`714`	`711`	`auto isEmpty = globalLogAttributesJson_.empty();`
`715`		`- std::ostringstream stream{`
`716`		`- std::move(globalLogAttributesJson_), std::ios_base::app};`
	`712`	`+ std::string stream{std::move(globalLogAttributesJson_)};`
`717`	`713`	`SimpleJsonWriter writer{stream};`
`718`	`714`	`if (isEmpty)`
`719`	`715`	`{`
`720`	`716`	`writer.startObject();`
`721`	`717`	`}`
`722`	`718`	`factory(writer);`
`723`		`- globalLogAttributesJson_ = stream.str();`
	`719`	`+ globalLogAttributesJson_ = std::move(stream);`
`724`	`720`	`}`
`725`	`721`	`};`
`726`	`722`
Original file line number	Diff line number	Diff line change
`@@ -212,35 +212,35 @@ TEST_CASE("Global attributes inheritable")`
`212`	`212`	`TEST_CASE("Test JsonWriter")`
`213`	`213`	`{`
`214`	`214`	`{`
`215`		`- std::ostringstream stream;`
	`215`	`+ std::string stream;`
`216`	`216`	`beast::SimpleJsonWriter writer{stream};`
`217`	`217`
`218`	`218`	`writer.writeString("\n");`
`219`		`- CHECK(writer.str() == "\"\\n\"");`
	`219`	`+ CHECK(writer.finish() == "\"\\n\"");`
`220`	`220`	`}`
`221`	`221`
`222`	`222`	`{`
`223`		`- std::ostringstream stream;`
	`223`	`+ std::string stream;`
`224`	`224`	`beast::SimpleJsonWriter writer{stream};`
`225`	`225`
`226`	`226`	`writer.writeString("\t");`
`227`		`- CHECK(writer.str() == "\"\\t\"");`
	`227`	`+ CHECK(writer.finish() == "\"\\t\"");`
`228`	`228`	`}`
`229`	`229`
`230`	`230`	`{`
`231`		`- std::ostringstream stream;`
	`231`	`+ std::string stream;`
`232`	`232`	`beast::SimpleJsonWriter writer{stream};`
`233`	`233`
`234`	`234`	`writer.writeString(std::string_view{"\0", 1});`
`235`		`- CHECK(writer.str() == "\"\\u0000\"");`
	`235`	`+ CHECK(writer.finish() == "\"\\u0000\"");`
`236`	`236`	`}`
`237`	`237`
`238`	`238`	`{`
`239`		`- std::ostringstream stream;`
	`239`	`+ std::string stream;`
`240`	`240`	`beast::SimpleJsonWriter writer{stream};`
`241`	`241`
`242`	`242`	`writer.writeString("\"\\");`
`243`		`- CHECK(writer.str() == "\"\\\"\\\\\"");`
	`243`	`+ CHECK(writer.finish() == "\"\\\"\\\\\"");`
`244`	`244`	`}`
`245`	`245`	`}`
`246`	`246`