Update rebar.config deps (major) by renovate[bot] · Pull Request #144 · williamthome/euneus

renovate · 2026-03-14T11:08:35Z

This PR contains the following updates:

Package	Update	Change
jiffy (source)	major	`1.1.2` → `2.0.1`
rebar3_lint (source)	major	`3.2.6` → `5.0.4`

Release Notes

davisp/jiffy (jiffy)

`v2.0.1`

Compare Source

What's Changed

Remove EEP0018 references by @nickva in #292
Fix typo in docs #293
Fixup license name to make Hex happy #295
Fix uninitialized var access on allocation failure (thanks @qzhuyan) #297
Update ffc.h : faster numbers parsing #299

Full Changelog: davisp/jiffy@2.0.0...2.0.1

`v2.0.0`

Compare Source

The changelog is at the bottom. What follows are some general highlights.

Performance

(I used https://github.com/nickva/bench Benchee-based json benchmark to test performance. Any perf
numbers mentioned below are from running that. There are some individual benchmarks referred to by
name such as "Issue 90" or "Canada", those are just types of inputs used in benchmarking, some have
mostly numbers, some mostly strings, some are mixed)

SIMD vectorization for ASCII scan-ahead loops in both decoder string parsing and encoder
string emission. This meant replacing the byte-at-a-time scans with 16/32-byte chunked compares.
The most interesting part is it was done without writing a single line of assembly, just relying
on compiler auto-vectorization. This showed a 15x performance improvement on encoding large
strings like in the "Issue 90" benchmark. To get even better auto-vectorizer behavior, it's
advisable to set -march=native or -march=x86-64-v3. That can make the auto-vectorizers on
recent compilers switch to using 256bit AVX2 registers and instructions.
UTF-8 skip-ahead in encoder and faster UTF-8 validation. This is like the scan-ahead loop for
ASCII, but it's for UTF-8 validation. This helps quite a bit on non-ASCII, Unicode-heavy inputs.
"UTF-8 unescaped" benchmark got a 5.8x speedup from it.
Use Ryu for number encoding. This is the exact Ryu version from the latest Erlang/OTP release
with all the updates and tweaks they added. This makes the float output the same as Erlang's.
However, this means the output is not exactly the same as before for Jiffy (we used to emit more
fractional digits, now it switches to the scientific notation a bit earlier). Number heavy
benchmarks like "Canada" showed a 2x speedup.
ffc.h for number parsing in the decoder. This is the fastest C number parser around at this
time. I worked with the upstream author to add a new API to it parse JSON numbers as a single call
which returns back either an integer or a double, as opposed pre-parsing to figure out which is
which first (kolemannix/ffc.h#22). Using this library yielded a 4x
speedup in the number-heavy "Canada" benchmark on decoding.
Faster array and map creation for building the result term in fewer steps. (In the processes
discovered that maps with duplicates created from NIFs were subtly broken in Erlang
erlang/otp#10976. The fix is now merged and should be in the recent patch
Erlang releases). This bulk creation improved decoding across the board. Some examples are
2.5x for "JSON Generator", 2.6x for "Github" and 3.3x for "Blockchain". Most of those
a mixed inputs so number parsing and scan-ahead played a role in there as well.
Branch hints (JIFFY_LIKELY / JIFFY_UNLIKELY) on encoder hot paths. I saw QuickJS library
doing this, so experimented around and saw few percent speedup from it.
Unity build. Having handled a few issues over the years related to enabling, disabling and
detecting LTO (Link-time optimization) compiler features, decided to side-step it and go with a
unity build. This is where we include all the source file into one jiffy.c file and compile
that. We get all the benefits of LTO but without having to juggle linker flags.

Yielding & scheduler behavior

Reduction count bumped to 4000 to match current Erlang VM defaults
Bytes per reduction lowered so cooperative yields fire more
often on long input. This results in better latency under contention without a
measurable throughput hit.

Since Jiffy is a NIF, it's crucial for it to never block schedulers and always yield appropriately.
As the concurrency increases it should degrade gracefully in proportion to the applied load. This is
not a trivial task to accomplish in a NIF, in general. Some json library NIFs use dirty schedulers,
however in cases where Jiffy is used that wouldn't work as that is still a limited resource and
during high concurrency it would lead to bottlenecks.

A separate benchmark, bench_scheduling.sh in https://github.com/nickva/bench runs concurrent JSON
encoding and decoding scaled by the number of schedulers. Testing with a few Erlang json libraries
shows something like this:

./bench_scheduling.sh
...
scheduler responsiveness check
  input:       citm-catalog.json duration: 2000
  schedulers:  12 online
  impls:       json, jiffy, simdjsone, jsone, jsx

[json]
  1x encdec                    n=84 p50=135.0ms p95=182.9ms p99=191.9ms max=196.7ms
  12x encdec                   n=86 p50=129.7ms p95=189.9ms p99=203.0ms max=206.2ms
  24x encdec                   n=87 p50=263.0ms p95=461.2ms p99=506.1ms max=527.1ms

[jiffy]
  1x encdec                    n=309 p50=38.3ms p95=51.9ms p99=57.4ms max=66.5ms
  12x encdec                   n=300 p50=41.2ms p95=52.5ms p99=59.7ms max=66.2ms
  24x encdec                   n=306 p50=80.2ms p95=111.8ms p99=118.8ms max=140.1ms

[simdjsone]
  1x encdec                    n=20 p50=690.1ms p95=784.6ms p99=784.6ms max=784.8ms
  12x encdec                   n=16 p50=790.9ms p95=887.5ms p99=887.5ms max=899.9ms
  24x encdec                   n=24 p50=1448.4ms p95=1876.7ms p99=1879.5ms max=1882.7ms

[jsone]
  1x encdec                    n=60 p50=213.1ms p95=261.8ms p99=263.9ms max=264.8ms
  12x encdec                   n=60 p50=204.9ms p95=329.8ms p99=345.0ms max=350.9ms
  24x encdec                   n=52 p50=440.1ms p95=700.3ms p99=773.3ms max=817.3ms

[jsx]
  1x encdec                    n=24 p50=398.8ms p95=539.0ms p99=544.1ms max=548.3ms
  12x encdec                   n=24 p50=391.5ms p95=684.9ms p99=687.0ms max=689.6ms
  24x encdec                   n=24 p50=1181.3ms p95=1479.0ms p99=1558.1ms max=1654.7ms

There we measure both the latency of sending a term back and forth between two encoder/decoder
processes, as well as the throughput (n is how many times we managed to do that).

Features

Pre-encoded JSON — embed already-encoded JSON fragments directly in a value being encoded,
saving a round-trip through the decoder. Use {json, IoData} terms and they will be embedded in
the emitted stream as is. This was a surprisingly popular feature over the years. Paul J. Davis
(Jiffy's original author) suggested a nice and quick patch to make it work so I went with that.
Encode UTF-8 atoms (on OTP 26+ only!) atoms with non-ASCII bytes now encode as their UTF-8
source. Unfortunately this is for OTP 26+ only.
Number-as-key encoding — integer/float map keys are encoded as string keys instead of
erroring. Both Python and Erlang/OTP's built-in json already does this.

Correctness & compliance

RFC 8259 100% compliance. A new test suite based on nst/JSONTestSuite is wired in and all
conformance tests pass.
Big List of Naughty Strings (BLNS) added in the test mix.

Build & CI

OTP 21 is the new minimum.
C coverage checks added so the test suite reports per-file C line coverage; several uncovered
paths were closed during this work.

Changelog

Add a missing else in utf8 validation by @nickva in #247
Fix some wextra warnings by @nickva in #248
Run prop tests in CI by @nickva in #249
Fix OTP 27 prop tests by @nickva in #250
Add C coverage checks by @nickva in #251
Plain ASCII scan ahead optimization in string decoding by @nickva in #252
Use the restrict pointer qualifier when decoding numbers by @nickva in #253
Use quick lookahead parsing for numbers by @nickva in #254
Plain ASCII scan ahead optimization in string encoding by @nickva in #255
Bump yielding reduction count to 4000 by @nickva in #256
Whitespace scan ahead optimization in decoder by @nickva in #257
Add bench folder to gitignore by @nickva in #258
Ignore .cache by @nickva in #259
Optimize dedupe_keys option by @nickva in #260
Switch to Ryu for float point encoding by @nickva in #261
Faster map encoding with enif_make_map_from_arrays by @nickva in #262
Faster array creation by @nickva in #263
No more FLTO by @nickva in #264
Add extra tests and cleanup to increase coverage by @nickva in #265
Add some NIF lifecyle coverage by @nickva in #266
Produce a unity build by @nickva in #267
Prevent forward slashes from breaking scan-ahead optimization by @nickva in #268
Test with the Big List of Naughty Strings (BLNS) by @nickva in #269
RFC 8259 Tests by @nickva in #270
Cleanup jiffy erl module by @nickva in #271
Another l2b/b2l cleanup by @nickva in #272
Header cleanups by @nickva in #274
100% compliance with RFC 8259 by @nickva in #273
Skip setting buffer to 0 for strtod and strtol by @nickva in #275
Fix potential segfault in termstack expansion by @nickva in #276
Optimize termstack_restore allocation by @nickva in #277
Use ffc.h library to parse numbers by @nickva in #278
Use branch predictors for encoding by @nickva in #280
Implement SIMD vectorization by @nickva in #279
Improve coverage even more by @nickva in #281
Reduce bytes per reduction a bit by @nickva in #282
Speed up UTF8 validation by about 25% by @nickva in #283
Simplify numerical overflow handling for doubles by @nickva in #284
Simplify and speed up number parsing by @nickva in #285
Encode UTF8 atoms by @nickva in #286
Allow number encoding as keys by @nickva in #287
Export 'encode_options/0' and 'decode_options/0' types by @emqplus in #184
Implement pre-encoded json by @nickva in #290
Remove dead yielding code by @nickva in #291
Skip-ahead for UTF8 encoding by @nickva in #289