json_parser | Simple lightweight header-only JSON Parser | JSON Processing library

Please, do not use Property Tree as a JSON library.

Boost 1.75.0 added a JSON library though!

As the other commenter said, it's not very clear what exactly you require, so let me just sketch a few similar use-cases:

The newline is not explicitly mentioned in the JSON RFC-7159 but it is defined as part of the POSIX standard for a line.

Incase you're interested in where the newline comes from you can take a look at the write_json_internal source code, we can see that there is an stream << std::endl; near the end of the method. Note that ...::write_json references write_json_internal.

Don't use Property Tree as if it's a JSON library. It has well known limitations: https://www.boost.org/doc/libs/1_75_0/doc/html/property_tree/parsers.html#property_tree.parsers.json_parser

Note especially the limitationssurrounding arrays.

Next up, you didn't write an array to begin with, instead writing a string. But since it's binary data, it may be a valid JSON string, and this could be a source of error.

Also, you probably don't need to copy the whole JSON again to put it in a buffer. Instead, boost::asio::buffer(resultString) will work (as long as you make sure that the lifetime of resultString is enough, like with buffer_).

Just testing a little does suggest that characters are being escaped correctly by write_json:

Live On Compiler Explorer

Depends on the actual usage context, but if you are familiar with the singleton pattern, this might be a way to go here in doubt if you are not able to forward the configuration information by design in a quite non-intrusive way (the latter should almost always be the preferred way but I know there are sometimes exceptional situations in reality). The context of the singleton needn't to be totally global in doubt since you can use a global singleton to ensure more "context-sensitive" branching if required.

But as mentioned: Try to solve this by design if the context of this configuration isn't that global in doubt. Provide a possibly quite central handler class (as sharedPtr for instance) that offers the configuration data on request. Then, solely the used objects' constructors require that one as a parameter.

Like I warn in my comment, Boost Property Tree is not a JSON library. This doesn't mean that what you ask for here is impossible.

It is possible. Let's pick Array and Matrix definitions:

C/C++ is well known for being in many cases faster than python.

Not in many cases, always.

Of course, if your C/C++ code is badly written, it can be as slow as you want.

I performed the test both in python using the built-in json library and in C++ using the external nlohmann JSON library.

The nlohmann JSON library is slower than other alternatives. It is definitely possible that it is slower than CPython's implementation. Use another library if you really need speed.

Having said that, please note that benchmarking is hard. It may be the case that, as @Jesper and @idclev mention, you are simply missing optimizations when compiling the C++ code.

is the json library by any chance written in any low level language and this is the main reason for performance, or is just pure python?

Yes, the CPython implementation is written in C as @jonrsharpe pointed out.

The actual problem was, that getting config fulfilled by using dlopen and dlsym and wrapping result into shared_ptr. So shared library was freed in blocking_get_result. So in the main pointer in the vtable became invalid.

You're calling run in both the thread

Your matrices are using space on the local call stack.

Try to making a class for them, which uses heap allocated data using smart pointers and/or some C++ standard container