如何最快将Boost Property Tree(ptree)序列化到vector？

Original Code #

std::vector<uint8_t> getWriteBuffer() { 
    boost::property_tree::ptree jsonTree=getJson(); //This function returns a json in a ptree 
    // I have this code, but is there any faster way to do this? 
    std::ostringstream jsonStream; 
    boost::property_tree::write_json(jsonStream, jsonTree); 
    std::string jsonString = jsonStream.str(); 
    std::vector<uint8_t> output(jsonString.begin(), jsonString.end()); 
    return output; 
}

Question #

Currently I'm serializing a boost::property_tree::ptree to a std::vector<uint8_t> by writing to an ostringstream, converting to a std::string, then copying to the vector. But I'm wondering if there's a faster way to do this serialization?

Answer #

Great question! Your current approach works, but it involves two unnecessary memory copies (one from the stringstream to the std::string, another from the string to the vector). We can eliminate these, and even explore faster alternatives if you're open to switching libraries.

1. Optimize with Boost.Iostreams (No Library Switch Needed)

The biggest win with your existing setup is cutting out the intermediate std::string and ostringstream by writing directly to the vector<uint8_t> using Boost's iostreams library. This lets you serialize the ptree straight into the vector, avoiding extra copies.

Here's how to implement it:

#include <boost/iostreams/device/back_inserter.hpp>
#include <boost/iostreams/stream.hpp>

std::vector<uint8_t> getWriteBuffer() {
    boost::property_tree::ptree jsonTree = getJson();
    
    std::vector<uint8_t> output;
    // Create a stream that writes directly to the vector
    boost::iostreams::back_insert_device<std::vector<uint8_t>> inserter(output);
    boost::iostreams::stream<boost::iostreams::back_insert_device<std::vector<uint8_t>>> jsonStream(inserter);
    
    boost::property_tree::write_json(jsonStream, jsonTree);
    jsonStream.flush(); // Ensure all data is flushed to the vector
    
    return output;
}

If you can estimate the approximate size of your serialized JSON, add output.reserve(estimated_size); right after creating the vector—this prevents repeated memory allocations as the vector grows, which adds another small performance boost.

2. Switch to a JSON-Specific Library (Bigger Performance Gains)

Boost.PropertyTree is a generic property tree implementation that supports multiple formats (JSON, XML, INI, etc.), which means its JSON serialization isn't optimized for speed. If performance is a critical concern, switching to a library built specifically for JSON will yield much better results.

Two top options:

• nlohmann/json: Extremely easy to use, with solid performance. It lets you serialize directly to a string (or stream) with minimal overhead.

  #include <nlohmann/json.hpp>
  using json = nlohmann::json;
  
  std::vector<uint8_t> getWriteBuffer() {
      // Assuming you convert your ptree to a nlohmann::json object first
      json jsonObj = convertPtreeToNlohmannJson(getJson());
      
      // Serialize directly to a string, then move into the vector
      std::string jsonStr = jsonObj.dump();
      return std::vector<uint8_t>(std::make_move_iterator(jsonStr.begin()), 
                                  std::make_move_iterator(jsonStr.end()));
  }
  

• rapidjson: Designed for maximum speed and minimal memory usage. It writes directly to a buffer, so you can copy the buffer straight into your vector.

  #include <rapidjson/writer.h>
  #include <rapidjson/stringbuffer.h>
  
  std::vector<uint8_t> getWriteBuffer() {
      // Convert your ptree to a rapidjson::Document
      rapidjson::Document jsonDoc = convertPtreeToRapidJsonDoc(getJson());
      
      rapidjson::StringBuffer buffer;
      rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
      jsonDoc.Accept(writer);
      
      // Copy the buffer directly into the vector
      return std::vector<uint8_t>(buffer.GetString(), buffer.GetString() + buffer.GetSize());
  }
  

Both libraries will outperform Boost.PropertyTree for JSON serialization, especially with larger datasets.

内容的提问来源于stack exchange，提问作者mans