How we made JSON.stringify more than twice as fast

by emschwartz • 12 months ago

458 168 12 months ago

hinkley12• 12 months ago

JSON encoding is a huge impediment to interprocess communication in NodeJS.

Sooner or later is seems like everyone gets the idea of reducing event loop stalls in their NodeJS code by trying to offload it to another thread, only to discover they’ve tripled the CPU load in the main thread.

I’ve seen people stringify arrays one entry at a time. Sounds like maybe they are doing that internally now.

If anything I would encourage the V8 team to go farther with this. Can you avoid bailing out for subsets of data? What about the CString issue? Does this bring faststr back from the dead?

jcdavis• 12 months ago

Based off of my first ever forays into node performance analysis last year, JSON.stringify was one of the biggest impediments to just about everything around performant node services. The fact that everyone uses stringify to for dict keys, the fact that apollo/express just serializes the entire response into a string instead of incrementally streaming it back (I think there are some possible workarounds for this, but they seemed very hacky)

As someone who has come from a JVM/go background, I was kinda shocked how amateur hour it felt tbh.

MehdiHK2• 12 months ago

JSON.stringify was one of the biggest impediments to just about everything around performant node services

That's what I experienced too. But I think the deeper problem is Node's cooperative multitasking model. A preemptive multitasking (like Go) wouldn't block the whole event-loop (other concurrent tasks) during serializing a large response (often the case with GraphQL, but possible with any other API too). Yeah, it does kinda feel like amateur hour.

hinkley12• 12 months ago

Based off of my first ever forays into node performance analysis last year, JSON.stringify was one of the biggest impediments to just about everything around performant node services

Just so. It is, or at least can be, the plurality of the sequential part of any Amdahl's Law calculation for Nodejs.

I'm curious if any of the 'side effect free' commentary in this post is about moving parts of the JSON calculation off of the event loop. That would certainly be very interesting if true.

However for concurrency reasons I suspect it could never be fully off. The best you could likely do is have multiple threads converting the object while the event loop remains blocked. Not entirely unlike concurrent marking in the JVM.

dmit• 12 months ago

Node is the biggest impediment to performant Node services. The entire value proposition is "What if you could hire people who write code in the most popular programming language in the world?" Well, guess what

brundolf• 12 months ago

Yeah. I think I've only ever found one situation where offloading work to a worker saved more time than was lost through serializing/deserializing. Doing heavy work often means working with a huge set of data- which means the cost of passing that data via messages scales with the benefits of parallelizing the work.

hinkley12• 12 months ago

I think the clues are all there in the MDN docs for web workers. Having a worker act as a forward proxy for services; you send it a URL, it decides if it needs to make a network request, it cooks down the response for you and sends you the condensed result.

Most tasks take more memory in the middle that at the beginning and end. And if you're sharing memory between processes that can only communicate by setting bytes, then the memory at the beginning and end represents the communication overhead. The latency.

But this is also why things like p-limit work - they pause an array of arbitrary tasks during the induction phase, before the data expands into a complex state that has to be retained in memory concurrent with all of its peers. By partially linearizing you put a clamp on peak memory usage that Promise.all(arr.map(...)) does not, not just the thundering herd fix.

dwattttt2• 12 months ago

Now to just write the processing code in something that compiles to WebAssembly, and you can start copying and sending ArrayBuffers to your workers!

Or I guess you can do it without the WebAssembly step.

hinkley12• 12 months ago

A JSON.toBuffer would be another good addition to V8. There are a couple code paths that look like they might do this, but from all accounts it goes Object->String->Buffer, and for speed you want to skip the intermediate.

nijave• 12 months ago

Same problem in Python. It'd be nice to have good/efficient IPC primitives with higher level APIs on top for common patterns

userbinator• 12 months ago

You mean:

JSON encoding is a huge impediment to communication

I wonder how much computational overhead JSON'ing adds to communications at a global scale, in contrast to just sending the bytes directly in a fixed format or something far more efficient to parse like ASN.1.

hinkley12• 12 months ago

No. Because painful code never gets optimized as much as less painful code. People convince themselves to look elsewhere, and an incomplete picture leads to local optima.

tgv2• 12 months ago

If anything I would encourage the V8 team to go farther with this.

That feels the wrong way to go. I would encourage the people that have this problem to look elsewhere. Node/V8 isn't well suited to backend or the heavier computational problems. Javascript is shaped by web usage, and it will stay like that for some time. You can't expect the V8 team to bail them out.

The Typescript team switched to Go, because it's similar enough to TS/JS to do part of the translation automatically. I'm no AI enthousiast, but they are quite good at doing idiomatic translations too.

com2kid2• 12 months ago

Node/V8 isn't well suited to backend

Node was literally designed to be good for one thing - backend web service development.

It is exceptionally good at it. The runtime overhead is tiny compared to the JVM, the async model is simple as hell to wrap your head around and has a fraction of the complexity of what other languages are doing in this space, and Node running on a potato of a CPU can handle thousands of requests per second w/o breaking a sweat using the most naively written code.

Also the compactness of the language is incredible, you can get a full ExpressJS service up and running, including auth, in less than a dozen lines of code. The amount of magic that happens is almost zero, especially compared to other languages and frameworks. I know some people like their magic BS (and some of the stuff FastAPI does is nifty), but Express is "what you see is what you get" by default.

The Typescript team switched to Go, because it's similar enough to TS/JS to do part of the translation automatically.

The TS team switched to go because JS is horrible at anything that isn't strings or doubles. The lack of an int type hinders the language, so runtimes do a lot of work to try and determine when a number can be treated like an int.

JS's type system is both absurdly flexible and also limiting. Because JS basically allows you to do anything with types, Typescript ends up being one of the most powerful type systems that has seen mass adoption. (Yes other languages have more powerful type systems, but none of them have the wide spread adoption TS does).

If I need to model a problem domain, TS is an excellent tool for doing so. If I need to respond to thousands of small requests, Node is an excellent tool for doing so. If I need to do some actual computation on those incoming requests, eh, maybe pick another tech stack.

But for the majority of service endpoints that consist of "get message from user, query DB, reformat DB response, send to user"? Node is incredible at solving that problem.

deadbabe2• 12 months ago

When it comes time to do serious work in Node, that's when you start using TypedArrays and SharedArrayBuffers and work with straight binary data. stringifying is mostly for toy apps and smaller projects.

hinkley12• 12 months ago

If I took all the coworkers I’ve had in 30 years of coding whom I could really trust with the sort of bit fiddling array buffers, I could populate maybe two companies and everyone else would be fucked.

TypedArray is a toy. Very few domains actually work well with this sort of data. Statistics, yes. Games? Do all the time, but also games: are full of glitches used by speed runners, due to games playing fast and loose to maintain an illusion they are doing much more per second than they should be able to.

DataView is a bit better. I am endlessly amazed at how many times I managed to read people talk about TypedArrays and SharedByteArrays before I discovered that DataView exists and has existed basically forever. Somebody should have mentioned it a lot, lot sooner.

zamalek3• 12 months ago

Sooner or later is seems like everyone gets the idea of reducing event loop stalls in their NodeJS code by trying to offload it to another thread, only to discover they’ve tripled the CPU load in the main thread.

Why not use structuredClone to communicate with the worker? So long as your object upholds all the rules you can pass it into postMessage directly.

hinkley12• 12 months ago

Structured clone only gets you a new object in this heap, not a new object in an isolate. You’re still doing stringify/parse under the hood every time you sendMessage.

cogman10• 12 months ago

It's a major problem for JVM performance as well. Json encoding is simply fundamentally an expensive thing to do.

One thing that improves performance for the JVM that'd be nice to see in node realm is that JSON serialization libraries can stream out the serialization. One of the major costs of JSON is the memory footprint. Strings take up a LOT more space in memory than a regular object does.

Since the JVM typically only uses JSON as a communication protocol, streaming it out makes a lot of sense. The IO (usually) takes long enough to give a CPU reprieve while simultaneously saving memory.

MutedEstate45• 12 months ago

I really like seeing the segmented buffer approach. It's basically the rope data structure trick I used to hand-roll in userland with libraries like fast-json-stringify, now native and way cleaner. Have you run into the bailout conditions much? Any replacer, space, or custom .toJSON() kicks you back to the slow path?

jonas21• 12 months ago

The part that was most surprising to me was how much the performance of serializing floating-point numbers has improved, even just in the past decade [1].

[1] https://github.com/jk-jeon/dragonbox?tab=readme-ov-file#perf...

jameshart6• 12 months ago

Roundtripping IEEE floating point values via conversion to decimal UTF-8 strings and back is a ridiculously fragile process, too, not just slow.

The difference between which values are precisely representable in binary and which are precisely representable in decimal means small errors can creep in.

gugagore• 12 months ago

You don't have to precisely represent the float in decimal. You just have to have each float have a unique decimal representation, which you can guarantee if you include enough digits: 9 for 32-bit floats, and 17 for 64-bit floats.

https://randomascii.wordpress.com/2012/02/11/they-sure-look-...

jk-jeon2• 12 months ago

A way to achieve perfect round-tripping was proposed back in 1990, by Steele and White (and likely they are not the first ones who came up with a similar idea). I guess their proposal probably wasn't extremely popular at least until 2000's, compared to more classical `printf`-like rounding methods, but it seems many languages and platforms these days do provide such round-tripping formatting algorithms as the default option. So, I guess nowadays roundtripping isn't that hard, unless people do something sophisticated without really understanding what they're doing.

kccqzy3• 12 months ago

Most languages in use (such as Python) have solved this problem ages ago. Take any floating point value other than NaN, convert it to string and convert the string back. It will compare exactly equal. Not only that, they are able to produce the shortest string representation.

iouser• 12 months ago

Did you run any tests/regressions against the security problems that are common with parsers? Seems like the solution might be at risk of creating CVEs later

rpearl• 12 months ago

...Do you think that v8 doesn't have tests for what might be one of the most executed userspace codepaths in the world?

taeric4• 12 months ago

I confess that I'm at a bit of a loss to know what sort of side effects would be common when serializing something? Is there an obvious class of reasons for this that I'm just accidentally ignoring right off?

vinkelhake• 12 months ago

A simple example is `toJSON`. If an object defines that method, it'll get invoked automatically by JSON.stringify and it could have arbitrary side effects.

I think it's less about side effects being common when serializing, just that their fast path avoids anything that could have side effects (like toJSON).

The article touches briefly on this.

taeric4• 12 months ago

Right, I get that you could define something to have side effects. My question is why would you? What are some expected visible side effects of converting something to json?

That said, I see that they called it out as you say, now. When I first read it, I thought they watched for side effects.

I'm assuming they have an allow list on all standard types. The date types, in particular, often have a toJson that seems like it should still be used? (Or am I wrong on that, too? :D )

kevingadd2• 12 months ago

Calling a property getter can have side effects, so if you serialize an object with a getter you have to be very cautious to make sure nothing weird happens underneath you during serialization.

People have exploited this sort of side effect to get bug bounties before via type confusion attacks, iirc.

taeric4• 12 months ago

Right, I get how you could make something that would cause issues. I'm curious why you would want to? :D

monster_truck• 12 months ago

I don't think v8 gets enough praise. It is fucking insane how fast javascript can be these days

andyferris• 12 months ago

Yeah, it is quite impressive!

It's a real example of "you can solve just about anything with a billion dollars" though :)

I'd prefer JavaScript kept evolving (think "strict", but "stricter", "stricter still", ...) to a simpler and easier to compile/JIT language.

ayaros• 12 months ago

Yes, this is what I want too. Give me "stricter" mode.

fngjdflmdflg4• 12 months ago

I want JS with sound types. It's interesting how sound types can't be added to JS because runtime checks would be too expensive, but then so much of what makes JS slow is having to check types all the time anyway, and the only way to speed it up is to retroactively infer the types. I want types plus a "use typechecked" that tells the VM I already did some agreed upon level of compile-time checks and now it only needs to do true runtime checks that can't be done at compile time.

ihuman• 12 months ago

Like asm.js was, before webassembly replaced it?

Cthulhu_5• 12 months ago

I'd prefer JavaScript kept evolving (think "strict", but "stricter", "stricter still", ...) to a simpler and easier to compile/JIT language.

This is / was ASM.js, a limited subset of JS without all the dynamic behaviour which allowed the interpreter to skip a lot of checks and assumptions. This was deprecated in favor of WASM - basically communicating that if you need the strictness or performance, use a different language.

As for JS strictness, eslint / biome with all the rules engaged will also make it strict.

shivawu• 12 months ago

On the other hand, I consider v8 the most extreme optimized runtime in a weird way, in that there’re like 100 people on the planet understand how it works, while the rest of us be like “why my JS not fast”

yieldcrv• 12 months ago

and then there are the people saying “why JS” before going on a archaic rant and then leaving the interview concluding their rejection was age discrimination

ot• 12 months ago

The SWAR escaping algorithm [1] is very similar to the one I implemented in Folly JSON a few years ago [2]. The latter works on 8 byte words instead of 4 bytes, and it also returns the position of the first byte that needs escaping, so that the fast path does not add noticeable overhead on escape-heavy strings.

[1] https://source.chromium.org/chromium/_/chromium/v8/v8/+/5cbc...

[2] https://github.com/facebook/folly/commit/2f0cabfb48b8a8df84f...

hairtuq• 12 months ago

If you want to optimize it a little more, you can combine isLess(s, 0x20) and isChar('"') into isLess(s ^ (kOnes * 0x02), 0x21) (this works since '"' is 0x22).

pyrolistical• 12 months ago

Optimizing the underlying temporary buffer

So array list instead of array?

greatgib• 12 months ago

An important question that was not addressed is whether the general path will be slower to account for what is needed to check first if the fast path can be used.

Leszek• 12 months ago

It's not - the general path is a bailout for the fast path which continues where the fast path stopped, so you don't have to check the whole object for fastness (and you get the fast path up until the bailout)

lifthrasiir2• 12 months ago

As usual, the advancement in double-to-string algorithms is usually driven by JSON (this time Dragonbox).

t1234s• 12 months ago

speed is always good!

stephenlf• 12 months ago

Yo nice

Tiberium• 12 months ago

V8 is extremely good, but (maybe due to JS itself?) it still falls short of LuaJIT and even JVM performance. Although at least for JVM it takes way longer to warm up than the other two.

MrBuddyCasino• 12 months ago

„even“

Hombre, you’re about the best there is.

xxs4• 12 months ago

that 'even' made me chuckle - exactly the same 'reaction'

Cthulhu_5• 12 months ago

maybe due to JS itself?

Nail on the head; a lot of JS overhead is due to its dynamic nature. asm.js disallowed some of this dynamic behaviour (like changing the shape of objects, iirc), meaning they could skip a lot of these checks.

mhh__• 12 months ago

It's JS, V8 is afaict much more advanced than luajit and jvm.

Although java also has the advantage of not having to be ~ real time (i.e. has a compiler)

jongjong3• 12 months ago

JSON serialization is already quite fast IMO so this is quite good. I think last time I compared JSON serialization to Protocol Buffers, JSON was just a little bit slower for typical scenarios but not materially so. These kinds of optimizations can shift the balance in terms of performance.

JSON is a great minimalist format which is both human and machine readable. I never quite understood the popularity of ProtoBuf; the binary format is a major sacrifice to readability. I get that some people appreciate the type validation but it adds a lot of complexity and friction to the transport protocol layer.

hamandcheese3• 12 months ago

For me the appeal of protobuf is the wire-format forward-backward compatibility.

It's hard enough to not break logical compatibility, so I appreciate not having to think too hard about wire compat. You can of course solve the same thing with JSON, but, well, YOU have to solve it.

(Also worth noting, there are a lot of things I don't like about the grpc ecosystem so I don't actually use it that much. But this is one of the pieces I really like a lot).

nasretdinov2• 12 months ago

Arguably JSON doesn't have this problem at all since it encodes the field names too. The only thing it doesn't handle is field renames, but I mean, come on, you know you can't rename a field in public API anyways :)

DanielHB• 12 months ago

I imagine compression of JSON also adds significant overhead compared to ProtoBuf on top of extra memory usage.

I don't disagree that people go for ProtoBuf a bit too eagerly though.

secondcoming• 12 months ago

A format cannot be both human and machine readable. JSON is human readable, that's the point of it. Human readability is great for debugging only but it has an overhead because it's not machine friendly. Protobuf messages are both smaller and quicker to decode. If you're in an environment where you're handling millions of messages per second binary formats pay dividends. The number of messages viewed by a human is miniscule so there's no real gain to having that slow path. Just write a message dump tool.

jongjong3• 12 months ago

Ah well with LLMs, the definition of 'machine-readable' has changed quite a bit.

xxs4• 12 months ago

machine readable

It is readable but it's not a good/fast format. IEEE754<->string is just expensive even w/ all the shortcuts and improvements. byte[]s have no good way to be presented either.

tisdadd• 12 months ago

I will need to check this vs the usual safe-stable-stringify package I usually use in my projects now when I'm back on the computer, but it is always nice to see the speedup.

65• 12 months ago

I'd like to see how object duplication now compares in speed when using JSON.parse(JSON.stringify()) vs. recursive duplication.

Cthulhu_5• 12 months ago

Also take `structuredClone()` in this comparison; I don't understand why parse/stringify is still a thing, it's a workaround. I'm sure there can be a special code path to make this particular use case super fast or infer that it needs to create a full copy of an object, but there shouldn't be one.

bgdkbtv• 12 months ago

Unrelated, but v8.dev website is incredibly fast! Thought it would be content preloading with link hovering but no. Refreshing

Culonavirus• 12 months ago

Speaking of websites, does anyone know when will this land in Node? Node 24 has v8 13.6, and this is 13.8... I mean, this seems like a too big of a performance upgrade to just put it in the next release, especially since Node 24 will be the next LTS version.

Snafuh• 12 months ago

There is a PR open since June. It's currently blocked by a MacOS CI issue.

https://github.com/nodejs/node/pull/58491

hereonout2• 12 months ago

It's also very simple and free of ads or any other extraneous clutter, a bit like hacker news, which is also fast.

There's probably a lesson in there somewhere.

qw• 12 months ago

Looking at the site it seems to be a (static?) HTML and shared "main.css" and "main.js" files. Both files can be cached by the browser, so it only needs to download a few KB of compressed HTML for each page. I don't think we would notice much of a difference in the navigation from one page to another if they used content preloading

It's how we used to make websites before SPA, and it's refreshing to see that it still makes a noticeable difference even on today's powerful CPUs and high speed networks.

dvrp• 12 months ago

Woah, I didn't know about Packed SIMD/SIMD within a register (SWAR).

notpushkin• 12 months ago

No indexed properties on objects: The fast path is optimized for objects with regular, string-based keys. If an object contains array-like indexed properties (e.g., '0', '1', ...), it will be handled by the slower, more general serializer.

Any idea why?

Timwi3• 12 months ago

I wonder that too. Are they saying that objects with integer-looking keys are serialized as JSON arrays?? Surely not...?

inbx0• 12 months ago

My guess would be because they affect property ordering, complicating the stringification.

The default object property iteration rules in JS define that numeric properties are traversed first in their numeric order, and only then others in the order they were added to the object. Since the numbers need to be in their numeric, not lexical, order, the engine would also need to parse them to ints before sorting.

    > JSON.stringify({b: null, 10: null, 1: null, a: null})
    '{"1":null,"10":null,"b":null,"a":null}'

seanwilson• 12 months ago

Slightly related: I die a little inside each time I see `JSON.parse(JSON.stringify(object))` thinking about the inefficiencies involved compared to how you'd do this in a more efficient language.

There's structuredClone (https://developer.mozilla.org/en-US/docs/Web/API/Window/stru... https://caniuse.com/?search=structuredClone) with baseline support (93% of users), but it doesn't work if fields contain DOM objects or functions meaning you might have to iterate over and preprocess objects before cloning so more error-prone, manual and again inefficient?

remify• 12 months ago

March 2022 is not that long ago for a codebase. It takes time but Javascript has come a long way and it's definitely going in the right direction.

mary-ext• 12 months ago

also depends on the codebase, if you use frameworks with deep reactivity like Vue, you can't do structuredClone without toRaw (which only works if the object is shallow) as it'd throw on proxy objects.

Svelte has `$state.snapshot()` for this reason I believe.

smagin• 12 months ago

Unrelated but I have the easiest design improvement for your website: change <html> background color to #4285f4 (same as in topbar) so it looks like a sheet of paper on a blue base

ykrishnan• 12 months ago

Yes...It does look better.

bob1029• 12 months ago

How is this compared to other ecosystems? I've been serializing JSON for about a decade and it's been so fast I haven't really thought about it. Simdjson can do gigabytes per second per core.

Once you factor in prefetching, branch prediction, etc., a highly optimized JSON serializer should be effectively free for most real world workloads.

The part where json sucks is IO overhead when modifying blobs. It doesn't matter how fast your serializer is if you have to push 100 megabytes to block storage every time a user changes a boolean preference.

enedil• 12 months ago

I think the main issue is that JSON is capable of serializing JavaScript Objects, which are often much more complex than a simple hashmap.

deathwarmedover• 12 months ago

Not that I doubt the value of the work, and the reasoning of its performance directly affecting common operations makes intuitive sense, but I would have liked to hear more about what concrete problems were being solved. Was there any interesting data across the V8 ecosystem about `JSON.stringify` dominating runtimes?

abdulhaq• 12 months ago

it doesn't need to dominate run times when it's being called by hundreds of millions of pages every day. The power saving worldwide will be considerable.

gampleman• 12 months ago

No replacer or space arguments: Providing a replacer function or a space/gap argument for pretty-printing are features handled exclusively by the general-purpose path. The fast path is designed for compact, non-transformed serialization.

Do we get this even if you call `JSON.stringify(data, null, 0)`? Or do the arguments literally have to be undefined?

tln• 12 months ago

I don't think so. I just got ~2.4 for a 512KB json using JSON.stringify(data, null, 0) and ~1.4 for JSON.stringify(data). JSON.stringify(data, undefined, undefined) was the same as JSON.stringify(data). Other combos were slower

https://microsoftedge.github.io/Demos/json-dummy-data/512KB.... Chrome 138.0.7204.184

countofarthur• 12 months ago

Reminded me the quote "do things quickly"

harel2• 12 months ago

Am I the only one that finds the use of "stringify" as the method name to serialise a data structure a bit... unsavoury on the tongue? A touch Mickey Mouse? I always wondered why this word was chosen for something so "core".

sphars• 12 months ago

According to the guy who created JavaScript, Brendan Eich[0]:

On Nov 16, 2008, at 11:57 PM, Peter Michaux wrote:
> The name "JSON.stringify" seems a little too "Web 2.0" cool to me.
Hardly. It's hacker dictionary material, old sk00l.
> Is there any reason a more usual and serious sounding option like "serialize" was not used?
Ugh, Web 1.0 my-first-Java-serializable-implementation anti-nostalgia vapors.

[0] https://web.archive.org/web/20100718152229/https://mail.mozi...

harel2• 12 months ago

That's exactly it though - That's the word: A bit too web 2.0....

Serialize, Marshal, toString: timeless. Stringify: Trendy, gone with the winds...

falconertc• 12 months ago

When the next best option is "serialize", suddenly stringify doesn't seem so bad. I would prefer a silly-sounding but immediately clear function to a more abstract concept.

Hendrikto• 12 months ago

Absolutely incredible how much effort has been put into making a horrible language bearable and performant.

Imagine how far we could have come if we started from a reasonable basis.

How we made JSON.stringify more than twice as fast

Related Stories