core/server(JSON): Use stateless allocator

Signed-off-by: Abhijat Malviya <[email protected]>

Author: abhijat

src/core/compact_object.cc

@@ -1624,7 +1624,7 @@ MemoryResource* CompactObj::memory_resource() {
 
 bool CompactObj::JsonConsT::DefragIfNeeded(PageUsage* page_usage) {
   if (JsonType* old = json_ptr; ShouldDefragment(page_usage)) {
-    json_ptr = AllocateMR<JsonType>(DeepCopyJSON(old, memory_resource()));
+    json_ptr = AllocateMR<JsonType>(DeepCopyJSON(old));
     DeleteMR<JsonType>(old);
     return true;
   }

src/core/compact_object_test.cc

@@ -455,14 +455,14 @@ TEST_F(CompactObjectTest, JsonTypeTest) {
     "children":[],"spouse":null}
   )";
   std::optional<JsonType> json_option2 =
-      JsonFromString(R"({"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}})", CompactObj::memory_resource());
+      JsonFromString(R"({"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}})");
 
   cobj_.SetString(json_str, false);
   ASSERT_TRUE(cobj_.ObjType() == OBJ_STRING);  // we set this as a string
   JsonType* failed_json = cobj_.GetJson();
   ASSERT_TRUE(failed_json == nullptr);
   ASSERT_TRUE(cobj_.ObjType() == OBJ_STRING);
-  std::optional<JsonType> json_option = JsonFromString(json_str, CompactObj::memory_resource());
+  std::optional<JsonType> json_option = JsonFromString(json_str);
   ASSERT_TRUE(json_option.has_value());
   cobj_.SetJson(std::move(json_option.value()));
   ASSERT_TRUE(cobj_.ObjType() == OBJ_JSON);  // and now this is a JSON type
@@ -477,7 +477,7 @@ TEST_F(CompactObjectTest, JsonTypeTest) {
   ASSERT_TRUE(json != nullptr);
   ASSERT_TRUE(json->contains("b"));
   ASSERT_FALSE(json->contains("firstName"));
-  std::optional<JsonType> set_array = JsonFromString("", CompactObj::memory_resource());
+  std::optional<JsonType> set_array = JsonFromString("");
   // now set it to string again
   cobj_.SetString(R"({"a":{}, "b":{"a":1}, "c":{"a":1, "b":2}})", false);
   ASSERT_TRUE(cobj_.ObjType() == OBJ_STRING);  // we set this as a string
@@ -504,7 +504,7 @@ TEST_F(CompactObjectTest, JsonTypeWithPathTest) {
             "title" : "The Night Watch",
             "author" : "Phillips, David Atlee"
         }]})";
-  std::optional<JsonType> json_array = JsonFromString(books_json, CompactObj::memory_resource());
+  std::optional<JsonType> json_array = JsonFromString(books_json);
   ASSERT_TRUE(json_array.has_value());
   cobj_.SetJson(std::move(json_array.value()));
   ASSERT_TRUE(cobj_.ObjType() == OBJ_JSON);  // and now this is a JSON type

src/core/json/json_object.cc

@@ -15,7 +15,7 @@ void InitJSONTLHeap(PMR_NS::memory_resource* mr) {
   detail::tl_mr = mr;
 }
 
-optional<JsonType> JsonFromString(string_view input, PMR_NS::memory_resource* mr) {
+optional<JsonType> JsonFromString(string_view input) {
   error_code ec;
   auto JsonErrorHandler = [](json_errc ec, const ser_context&) {
     VLOG(1) << "Error while decode JSON: " << make_error_code(ec).message();
@@ -35,7 +35,7 @@ optional<JsonType> JsonFromString(string_view input, PMR_NS::memory_resource* mr
   auto parser_options = jsoncons::json_options{}.max_nesting_depth(
       std::min(json_nesting_depth_limit, uint32_t(input.size() / 2)));
 
-  json_decoder<JsonType> decoder(std::pmr::polymorphic_allocator<char>{mr});
+  json_decoder<JsonType> decoder;
   json_parser parser(parser_options, JsonErrorHandler);
 
   parser.update(input);
@@ -47,10 +47,10 @@ optional<JsonType> JsonFromString(string_view input, PMR_NS::memory_resource* mr
   return nullopt;
 }
 
-JsonType DeepCopyJSON(const JsonType* j, PMR_NS::memory_resource* mr) {
+JsonType DeepCopyJSON(const JsonType* j) {
   std::string serialized;
   j->dump(serialized);
-  auto deserialized = JsonFromString(serialized, mr);
+  auto deserialized = JsonFromString(serialized);
   DCHECK(deserialized.has_value());
   return std::move(deserialized.value());
 }

src/core/json/json_object.h

@@ -65,15 +65,15 @@ bool operator!=(const JSONConsAllocator<T>&, const JSONConsAllocator<U>&) noexce
   return false;
 }
 
-using JsonType = jsoncons::pmr::json;
+using JsonType = jsoncons::basic_json<char, jsoncons::sorted_policy, JSONConsAllocator<char>>;
 
 // Build a json object from string. If the string is not legal json, will return nullopt
-std::optional<JsonType> JsonFromString(std::string_view input, PMR_NS::memory_resource* mr);
+std::optional<JsonType> JsonFromString(std::string_view input);
 
 // Deep copy a JSON object, by first serializing it to a string and then deserializing the string.
 // The operation is intended to help during defragmentation, by copying into a page reserved for
 // malloc.
-JsonType DeepCopyJSON(const JsonType* j, PMR_NS::memory_resource* mr);
+JsonType DeepCopyJSON(const JsonType* j);
 
 inline auto MakeJsonPathExpr(std::string_view path, std::error_code& ec)
     -> jsoncons::jsonpath::jsonpath_expression<JsonType> {

src/core/json/jsonpath_test.cc

@@ -39,7 +39,7 @@ class TestDriver : public Driver {
 template <typename JSON> JSON ValidJson(string_view str);
 
 template <> JsonType ValidJson<JsonType>(string_view str) {
-  auto res = ::dfly::JsonFromString(str, pmr::get_default_resource());
+  auto res = ::dfly::JsonFromString(str);
   CHECK(res) << "Failed to parse json: " << str;
   return *res;
 }

src/core/page_usage_stats_test.cc

@@ -191,7 +191,7 @@ TEST_F(PageUsageStatsTest, JSONCons) {
   // encoding.
   std::string_view data{R"#({"data": "some", "count": 1, "checked": false})#"};
 
-  auto parsed = JsonFromString(data, &m_);
+  auto parsed = JsonFromString(data);
   EXPECT_TRUE(parsed.has_value());
 
   c_obj_.SetJson(std::move(parsed.value()));

src/server/cluster/cluster_config.cc

@@ -309,7 +309,7 @@ optional<ClusterShardInfos> BuildClusterConfigFromJson(const JsonType& json) {
 /* static */
 shared_ptr<ClusterConfig> ClusterConfig::CreateFromConfig(string_view my_id,
                                                           std::string_view json_str) {
-  optional<JsonType> json_config = JsonFromString(json_str, PMR_NS::get_default_resource());
+  optional<JsonType> json_config = JsonFromString(json_str);
   if (!json_config.has_value()) {
     LOG(ERROR) << "Can't parse JSON for ClusterConfig " << json_str;
     return nullptr;

src/server/json_family.cc

@@ -341,8 +341,7 @@ void SendJsonString(const OpResult<string>& result, RedisReplyBuilder* rb) {
   if (result) {
     const string& json_str = result.value();
     if (rb->IsResp3()) {
-      std::optional<JsonType> parsed_json =
-          JsonFromString(json_str, PMR_NS::get_default_resource());
+      std::optional<JsonType> parsed_json = JsonFromString(json_str);
       if (parsed_json) {
         Send(parsed_json.value(), rb);
         return;
@@ -476,7 +475,7 @@ std::optional<std::string> ConvertJsonPathToJsonPointer(string_view json_path) {
    result before invoking SetJsonSize. Note that even after calling std::move on an optional, it may
    still hold the JSON value, which can lead to incorrect memory tracking. */
 std::optional<JsonType> ParseJSONFromString(std::string_view input) {
-  return dfly::JsonFromString(input, CompactObj::memory_resource());
+  return dfly::JsonFromString(input);
 }
 
 OpStatus SetFullJson(const OpArgs& op_args, string_view key, string_view json_str) {
@@ -557,8 +556,7 @@ OpResult<bool> SetPartialJson(const OpArgs& op_args, string_view key,
     path_exists = true;
     if (!is_nx_condition) {
       value_was_set = true;
-      *val = JsonType(parsed_json.value(),
-                      std::pmr::polymorphic_allocator<char>{CompactObj::memory_resource()});
+      *val = JsonType(parsed_json.value(), JSONConsAllocator<char>{});
     }
     return {};
   };

src/server/json_family_memory_test.cc

@@ -37,7 +37,7 @@ size_t GetMemoryUsage() {
 
 size_t GetJsonMemoryUsageFromString(std::string_view json_str) {
   size_t start = GetMemoryUsage();
-  auto json = dfly::JsonFromString(json_str, JsonFamilyMemoryTest::GetMemoryResource());
+  auto json = dfly::JsonFromString(json_str);
   if (!json) {
     return 0;
   }
@@ -111,7 +111,7 @@ TEST_F(JsonFamilyMemoryTest, JsonConsDelTest) {
 
   size_t start = GetMemoryUsage();
 
-  auto json = dfly::JsonFromString(start_json, JsonFamilyMemoryTest::GetMemoryResource());
+  auto json = dfly::JsonFromString(start_json);
   void* ptr =
       JsonFamilyMemoryTest::GetMemoryResource()->allocate(sizeof(JsonType), alignof(JsonType));
   JsonType* json_on_heap = new (ptr) JsonType(std::move(json).value());

src/server/rdb_load.cc

@@ -984,7 +984,7 @@ void RdbLoaderBase::OpaqueObjLoader::HandleBlob(string_view blob) {
   } else if (rdb_type_ == RDB_TYPE_JSON) {
     size_t start_size = static_cast<MiMemoryResource*>(CompactObj::memory_resource())->used();
     {
-      auto json = JsonFromString(blob, CompactObj::memory_resource());
+      auto json = JsonFromString(blob);
       if (json) {
         pv_->SetJson(std::move(*json));
       } else {