std.manifestJson is slow and memory inefficient, should be implemented as a native builtin

[HT154]

I have a use case where I need to serialize multiple large objects to JSON. I'm currently using std.manifestJson to do this. I'm finding this both slow, and memory inefficient.

Here's a representative benchmark

Short-circuiting manifestation using std.manifestJson({}):

% /usr/bin/time -l do-my-work # this time implementation is built into macOS
        5.16 real        13.77 user         3.63 sys
 166146048  maximum resident set size # peak memory footprint in bytes
         0  average shared memory size
         0  average unshared data size
         0  average unshared stack size
    400646  page reclaims
         0  page faults
         0  swaps
         0  block input operations
         0  block output operations
        41  messages sent
       113  messages received
         0  signals received
       134  voluntary context switches
     16460  involuntary context switches

Using std.manifestJson(<actual data>):

% /usr/bin/time -l do-my-work
       11.85 real        20.41 user         3.86 sys
 247922688  maximum resident set size
         0  average shared memory size
         0  average unshared data size
         0  average unshared stack size
    435074  page reclaims
         0  page faults
         0  swaps
         0  block input operations
         0  block output operations
        41  messages sent
       105  messages received
         0  signals received
       222  voluntary context switches
     30451  involuntary context switches

As you can see, this more than doubles the execution time and multiplies the memory footprint by around 1.5x.

It's hard to imagine that JSON manifestation would have this same impact if implemented natively in C++

[sbarzowski]

Hey, if you have performance issues, you may want to try our newer implementation https://github.com/google/go-jsonnet, which is way faster in general (and I think it has a native implementation of manifestJson) in particular).

And yes, a native implementation could certainly help. I'm not sure if your benchmark is representative, though. Jsonnet is a lazy language, so it's possible, that some stuff doesn't get evaluated at all it doesn't affect the output.

[HT154]

I’m unfortunately firmly tied to the C++ implementation for the time being, partially because I’m using the Python bindings, and partially because I’m using jsonnetfmt. There would have to be a lot of tooling and process changes to get me onto the faster implementation.

[sbarzowski]

Maybe it's not that bad?

partially because I’m using the Python bindings,

Experimental Python bindings for go-jsonnet are available and they are supposed to be a drop-in replacement. You need an up to date Go toolchain to install it, but otherwise it's just pip install gojsonnet away. You can give it a try. It should be a matter of replacing _jsonnet with _gojsonnet in Python code.

and partially because I’m using jsonnetfmt

A new implementation jsonnetfmt in go-jsonnet is available (no C or Python API for that though). You can also use jsonnetfmt from here and the interpreter from there.

[HT154]

I’ll take a look! It’s been a hot minute since I checked on the differences between the implementations. Introducing a go tool chain into my CI dependencies is less than ideal, but I might be able to build my own wheel for it. Thanks 😊