Efficient way of CBOR serializing big chunk of binary data

[Jamaslab]

Hey there,
So I'm trying the following code:

std::vector<uint8_t> bytes;
bytes.resize(10000000);
nlohmann::json json;
json["data"] = bytes;
auto retval = nlohmann::json::to_cbor(json);
auto back_json = nlohmann::json::from_cbor(retval);

This operation can take up some time (not a real benchmark but takes up to 53 seconds on my machine, quite a lot considering that data is already binary).
Is there a suggested way to speed it up?

---

EDIT
I did some additional tests and I managed to reduce drastically the time by using the binary container:

std::vector<uint8_t> bytes;
bytes.resize(10000000);
nlohmann::json json;
auto start = std::chrono::high_resolution_clock::now();
json["data"] = nlohmann::json::binary(std::move(bytes));
auto end = std::chrono::high_resolution_clock::now();
std::cout << "Assign: " << std::chrono::duration_cast<std::chrono::microseconds>(end-start).count() << " us" << std::endl;

start = std::chrono::high_resolution_clock::now();
auto retval = nlohmann::json::to_cbor(json);
end = std::chrono::high_resolution_clock::now();
std::cout << "Serialize: " << std::chrono::duration_cast<std::chrono::microseconds>(end-start).count() <<  " us" << std::endl;

start = std::chrono::high_resolution_clock::now();
auto back_json = nlohmann::json::from_cbor(retval);
end = std::chrono::high_resolution_clock::now();
std::cout << "Deserialize: " << std::chrono::duration_cast<std::chrono::microseconds>(end-start).count() <<  " us" << std::endl;

This is the output:

Assign: 37 us
Serialize: 727701 us
Deserialize: 2424147 us

I find still the from_cbor operation quite slow, is there a way to increase the performance on this side?

[nlohmann]

The from_cbor function is parsing the binary input and creates a JSON representation in memory. If you don't need it, you can implement your own SAX parser and decide what happens with the values coming from the parser.

And: did you try to compile with optimizations? Running the code on my MacBook Pro with -O3, I get

Assign: 40 us
Serialize: 26668 us
Deserialize: 60489 us

[epvbergen]

But what if the CBOR will live a lot longer than the parsed representation? And what if we don't run on a MacBook but an embedded platform?

I think having the option of using the various value type template parameters to basic_json to put user supplied smart pointers or weak references would be absolutely valid. What it needs is not a duplication of all the value types (as ref/non-ref), but a clearer contract between basic_json and the supplied types in as template parameters to basic_json.

[nlohmann]

In any case, compiling with optimizations would be beneficial ;-)

I'm afraid the library as of now does not support such customization. The best way to avoid copies is to define a SAX parser and decide, for each value returned from the parser, what to do with it.

[Jamaslab]

@epvbergen I’m also on an embedded platform. Currently is not my priority, but when I go back to it I’ll post my solution here below.

[Jamaslab]

Truly I compiled in debug mode, my bad, sorry for this.

However I think I'll go for a custom SAX parser as I'd like to leave it as binary during the parsing.

Thanks a lot!

[nlohmann]

Ok, please open another issue if you need help.