json-benchmark VS json

I don’t really understand what this is trying to prove:

- you don’t seem to specify the size of the input. This is the most important omission

- you are constructing an optimised representation (in this case, strict with fields in the right places) instead of a generic ‘dumb’ representation that is more like a tree of python dicts

- rust is not a ‘moderately fast language’ imo (though this is not a very important point. It’s more about how optimised the parser is, and I suspect that serde_json is written in an optimised way, but I didn’t look very hard).

I found[1], which gives serde_json to a dom 300-400MB/s on a somewhat old laptop cpu. A simpler implementation runs at 100-200, a very optimised implementation gets 400-800. But I don’t think this does that much to confirm what I said in the comment you replied to. The numbers for simd json are a bit lower than I expected (maybe due to the ‘dom’ part). I think my 50MB/a number was probably a bit off but maybe the python implementation converts json to some C object and then converts that C object to python objects. That might half your throughput (my guess is that this is what the ‘strict parse’ case for rustc_serialise is roughly doing).

[1] https://github.com/serde-rs/json-benchmark

But the code OP posted deserializes JSON without knowing anything about the structure, which is known to be slow in serde-json and doesn't appear to be the focus for the library. The json and json-deserializer crates should perform much better in that scenario.

Of course that doesnt mean that in practice the available libraries are as optimized. Did you try actix? It tends to be faster than rocket. Also json-rust and simd-json are usually faster than serde-json, when you don't deserialize a known structure. Here are some benchmarks: https://github.com/serde-rs/json-benchmark

The data for the test is taken from here: https://github.com/serde-rs/json-benchmark/tree/master/data

Here are some benchmarks https://github.com/serde-rs/json-benchmark

I found two projects: * https://github.com/djkoloski/rust_serialization_benchmark - doesn't use Serde zero copy * https://github.com/serde-rs/json-benchmark - has copy vs borrowed, but the results were the same for both, so something's off there

Rust has a good enough standard library (I’d say comparable to C++), that you don’t really need packages for a lot of stuff. Most of my projects have 1 or 2 dependencies. Most of the time I am pulling in a JS parser (serde) and a parallelization library (rayon). These are both high performance libraries that make writing very fast (serde can handle 850 MB/s on a 5 year old laptop cpu per their benchmarks). Rayon is one of the best parallelism libraries I’ve worked with.

Oh wow. So serde_json doesn't roundtrip floats by default, it uses some imprecise faster algorithm https://github.com/serde-rs/json/issues/707

Good thing there's msgpack I guess.

tokio / hyper / toml / serde / serde_json / json5 / console

Serde JSON, an extension of the serde crate that enables the serialization and deserialization of Rust structs.

To serialize and deserialize data, we'll employ the popular serde crate along with serde_json. This will allow us to easily convert between Rust types and JSON when working with API requests and responses. For async operations we'll use the Rust futures crate.

From the Cargo.toml file above, we can see that the Perseus version at the time of publication is 0.4.2 and has the following dependencies that are common to both the engine side (server-side) and client side of a Perseus application: sycamore, serde, and serde_json.

serde_json

Number parsing uses a fairly naive but uses a lossless algorithm in musli-json. In serde_json they use a fork of lexical I haven't wrapped my head around. I wanted something simple to start with.

Your best best would be to use an enum. Either your own or something like the one from serde_json depending on what you are trying to do.

Don't do that if you care about memory usage. In your toy program, I wouldn't be surprised if memory usage was a lot better if you used Box instead. (even if it doesn't look like it, you can handle almost all the use cases of serde_json::Value with it, often not much less convenient)