cv VS json-benchmark

Rust can absolutely be used without unsafe to create some of the fastest code out there, but you need to try and use data-oriented design where possible to make things flow smoothly and avoid runtime checks. The hardest thing to use data-oriented design for, in my opinion, is graphs. I find that actor systems can be used instead of graphs, but it is difficult. Generally I end up using slotmap to make multiple arenas and then putting them into one large object with lots of methods to operate on the graph structure. If you want an example of that, this is probably the most complicated code I have made this way: https://github.com/rust-cv/cv/blob/511024feaa077a9af377cca7b654ad3d57d3bd6a/cv-sfm/src/lib.rs. It may not be entirely helpful to understand the whole codebase, but if you are curious to see how I do graphs in Rust with slotmap, this can be a good reference.

This is a nice guide, but ultimately openCV should be rewritten in rust. It would avoid all of these headaches. Please checkout and support https://github.com/rust-cv/cv

It is, more or less, my first larger rust project. It uses the opencv crate, but I only recommend to have a look at rust-cv instead! It uses SQLite/sqlx for storing the matchings, actix-web for serving the webview and a lot of rayon for parallel processing.

You may want to take a look at our project Rust CV https://github.com/rust-cv/cv.

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.