fastsimdjson 0.7.0__tar.gz → 0.8.0__tar.gz

{fastsimdjson-0.7.0/src/fastsimdjson.egg-info → fastsimdjson-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastsimdjson
-Version: 0.7.0
+Version: 0.8.0
 Summary: Fast JSON parsing for Python, built on simdjson
 Author-email: Daniel Lemire <daniel@lemire.me>
 License-Expression: Apache-2.0
@@ -42,7 +42,8 @@ function is faster still. It also reads streams of documents (NDJSON, JSON
 Lines), on many threads with free-threaded Python, and can extract only the
 fields you need from each document. It writes JSON in two ways: `dumps` returns the same `str` as
 `json.dumps`, and `dumpb` returns the same `bytes` as `orjson.dumps`, as fast
-as orjson.
+as orjson; `dumpb_many` writes NDJSON, on many threads with free-threaded
+Python.
 
 With pip:
 
@@ -158,6 +159,30 @@ serialize dataclasses, `datetime`, `date`, `time`, `UUID`, numpy arrays or
 `OPT_PASSTHROUGH_DATACLASS` and `OPT_PASSTHROUGH_DATETIME` were set, and the
 options that concern only these types are accepted and have no effect.
 
+### `dumpb_many`: NDJSON, on several threads
+
+```python
+data = fastsimdjson.dumpb_many(records)               # b'{...}\n{...}\n'
+data = fastsimdjson.dumpb_many(records, threads=16)   # free-threaded Python
+```
+
+`dumpb_many(records, default=None, option=None, *, threads=None)` returns
+the records (a list, a tuple or any iterable) as NDJSON `bytes`: each record
+as `dumpb` writes it, followed by a newline, so that the output reads back
+with `loads_many(data, format="lines")`. `default` and `option` are those of
+`dumpb`, except `OPT_INDENT_2`, which would spread a record over several
+lines (`ValueError`); `OPT_APPEND_NEWLINE` changes nothing.
+
+On free-threaded Python, `threads=N` writes chunks of records on N threads at
+once (`threads=0` or `None`: one per processor), with the worker threads of
+`map_many`. The output and the errors are those of one thread: when records
+cannot be serialized, the error of the first of them is raised (`default` may
+then have been called on later records, in other threads, and it must be
+safe to call from several threads at once). With the GIL, the calling thread
+does all the work. Like `dumpb`, `dumpb_many` does not crash when other
+threads change the records meanwhile, but the output then reflects some of
+the changes and not others.
+
 ### Files
 
 ```python
@@ -380,7 +405,7 @@ geometric mean over the 22 files (higher is better).
 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_loads_dark.png">
-  <img src="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_loads.png" width="80%" alt="Parsing JSON in Python: fastsimdjson loads 0.78 GB/s, orjson 0.60, msgspec 0.53, jiter 0.48, pysimdjson 0.44, cysimdjson 0.43, ujson 0.37, python-rapidjson 0.24, simplejson 0.23, json 0.22">
+  <img src="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_loads.png" width="80%" alt="Parsing JSON in Python: fastsimdjson loads 0.78 GB/s, orjson 0.60, msgspec 0.53, jiter 0.48, jiter without its string cache 0.44, pysimdjson 0.44, cysimdjson 0.43, ujson 0.37, python-rapidjson 0.24, simplejson 0.23, json 0.22">
 </picture>
 
 | parser | GB/s | vs `json.loads` |
@@ -391,7 +416,8 @@ geometric mean over the 22 files (higher is better).
 | ujson 6.0.0 | 0.37 | 1.66× |
 | cysimdjson 26.27 | 0.43 | 1.96× |
 | pysimdjson 7.0.2 | 0.44 | 1.98× |
-| jiter 0.17.0 | 0.48 | 2.21× |
+| jiter 0.17.0 (no string cache) | 0.44 | 2.00× |
+| jiter 0.17.0 (string cache, the default) | 0.48 | 2.21× |
 | msgspec 0.22.0 | 0.53 | 2.42× |
 | orjson 3.12.0 | 0.60 | 2.74× |
 | **fastsimdjson `loads`** | **0.78** | **3.53×** |
@@ -407,7 +433,7 @@ the collector enabled and 1.22× with it disabled (geometric means); without
 the collector, `canada.json`, `mesh.json` and `numbers.json` are ties. yyjson 4.0.6 is left out: it
 returns wrong strings for non-ASCII text. jiter (the parser of pydantic)
 caches strings by default; turning the cache off (`cache_mode=False`) makes it
-slower here (0.44 GB/s).
+slower here.
 
 Parsing is no longer the bottleneck. simdjson alone parses these files at
 3.1 GB/s. It accounts for about a third of the time of `loads`; the rest goes
@@ -422,12 +448,14 @@ and the screen name of the 100 statuses of `twitter.json`:
 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_parse_dark.png">
-  <img src="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_parse.png" width="80%" alt="Reading part of twitter.json: fastsimdjson parse 158 µs, pysimdjson 179, cysimdjson 229, msgspec 336, fastsimdjson loads 861, orjson 1009, json 3922">
+  <img src="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_parse.png" width="80%" alt="Reading part of twitter.json: fastsimdjson parse 158 µs, pysimdjson 179, cysimdjson 229, msgspec 336, fastsimdjson loads 861, orjson 1009, jiter 1281, jiter without its string cache 1592, json 3922">
 </picture>
 
 | method | µs |
 |---|---:|
 | `json.loads` | 3922 |
+| jiter (no string cache) | 1592 |
+| jiter (string cache) | 1281 |
 | orjson | 1009 |
 | fastsimdjson `loads` | 861 |
 | msgspec (typed `Struct`) | 336 |
@@ -481,6 +509,18 @@ times faster than msgspec and 10 times faster than `json`. The comparison was
 run on a processor with AVX-512, which `dumpb` and orjson both use to escape
 strings; other x64 processors use SSE2 and ARM processors NEON.
 
+### Writing NDJSON with `dumpb_many`
+
+The 593,945 events of two hours of [GH Archive](https://www.gharchive.org/)
+(1.87 GB of NDJSON), written back as NDJSON from Python objects. With the
+GIL (Python 3.14.6), one thread: `orjson.dumps` on each record, joined, runs
+at 0.94 GB/s, `dumpb` on each record at 1.07 GB/s, and `dumpb_many` at
+1.41 GB/s. On free-threaded Python 3.14.6t, GB/s:
+
+| threads | 1 | 8 | 32 | 64 |
+|---|---:|---:|---:|---:|
+| `dumpb_many(records, threads=N)` | 1.3 | 6.0 | 11 | 12 |
+
 ### Streams with `loads_many`
 
 20 MB of NDJSON (5268 objects and arrays, one per line), made from the same
@@ -488,12 +528,14 @@ files; best of three runs:
 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_ndjson_dark.png">
-  <img src="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_ndjson.png" width="80%" alt="Reading NDJSON: fastsimdjson parse_many 0.94 GB/s, loads_many 0.38, msgspec decode_lines 0.37, fastsimdjson loads per line 0.33, msgspec decode per line 0.27, orjson per line 0.26, json per line 0.12">
+  <img src="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_ndjson.png" width="80%" alt="Reading NDJSON: fastsimdjson parse_many 0.94 GB/s, loads_many 0.38, msgspec decode_lines 0.37, fastsimdjson loads per line 0.33, msgspec decode per line 0.27, orjson per line 0.26, jiter per line 0.22, jiter without its string cache per line 0.20, json per line 0.12">
 </picture>
 
 | method | ms | GB/s |
 |---|---:|---:|
 | `json.loads` on each line | 169 | 0.12 |
+| jiter on each line (no string cache) | 98 | 0.20 |
+| jiter on each line (string cache) | 90 | 0.22 |
 | orjson on each line | 77 | 0.26 |
 | msgspec `decode` on each line | 74 | 0.27 |
 | fastsimdjson `loads` on each line | 60 | 0.33 |

{fastsimdjson-0.7.0 → fastsimdjson-0.8.0}/README.md

@@ -10,7 +10,8 @@ function is faster still. It also reads streams of documents (NDJSON, JSON
 Lines), on many threads with free-threaded Python, and can extract only the
 fields you need from each document. It writes JSON in two ways: `dumps` returns the same `str` as
 `json.dumps`, and `dumpb` returns the same `bytes` as `orjson.dumps`, as fast
-as orjson.
+as orjson; `dumpb_many` writes NDJSON, on many threads with free-threaded
+Python.
 
 With pip:
 
@@ -126,6 +127,30 @@ serialize dataclasses, `datetime`, `date`, `time`, `UUID`, numpy arrays or
 `OPT_PASSTHROUGH_DATACLASS` and `OPT_PASSTHROUGH_DATETIME` were set, and the
 options that concern only these types are accepted and have no effect.
 
+### `dumpb_many`: NDJSON, on several threads
+
+```python
+data = fastsimdjson.dumpb_many(records)               # b'{...}\n{...}\n'
+data = fastsimdjson.dumpb_many(records, threads=16)   # free-threaded Python
+```
+
+`dumpb_many(records, default=None, option=None, *, threads=None)` returns
+the records (a list, a tuple or any iterable) as NDJSON `bytes`: each record
+as `dumpb` writes it, followed by a newline, so that the output reads back
+with `loads_many(data, format="lines")`. `default` and `option` are those of
+`dumpb`, except `OPT_INDENT_2`, which would spread a record over several
+lines (`ValueError`); `OPT_APPEND_NEWLINE` changes nothing.
+
+On free-threaded Python, `threads=N` writes chunks of records on N threads at
+once (`threads=0` or `None`: one per processor), with the worker threads of
+`map_many`. The output and the errors are those of one thread: when records
+cannot be serialized, the error of the first of them is raised (`default` may
+then have been called on later records, in other threads, and it must be
+safe to call from several threads at once). With the GIL, the calling thread
+does all the work. Like `dumpb`, `dumpb_many` does not crash when other
+threads change the records meanwhile, but the output then reflects some of
+the changes and not others.
+
 ### Files
 
 ```python
@@ -348,7 +373,7 @@ geometric mean over the 22 files (higher is better).
 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_loads_dark.png">
-  <img src="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_loads.png" width="80%" alt="Parsing JSON in Python: fastsimdjson loads 0.78 GB/s, orjson 0.60, msgspec 0.53, jiter 0.48, pysimdjson 0.44, cysimdjson 0.43, ujson 0.37, python-rapidjson 0.24, simplejson 0.23, json 0.22">
+  <img src="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_loads.png" width="80%" alt="Parsing JSON in Python: fastsimdjson loads 0.78 GB/s, orjson 0.60, msgspec 0.53, jiter 0.48, jiter without its string cache 0.44, pysimdjson 0.44, cysimdjson 0.43, ujson 0.37, python-rapidjson 0.24, simplejson 0.23, json 0.22">
 </picture>
 
 | parser | GB/s | vs `json.loads` |
@@ -359,7 +384,8 @@ geometric mean over the 22 files (higher is better).
 | ujson 6.0.0 | 0.37 | 1.66× |
 | cysimdjson 26.27 | 0.43 | 1.96× |
 | pysimdjson 7.0.2 | 0.44 | 1.98× |
-| jiter 0.17.0 | 0.48 | 2.21× |
+| jiter 0.17.0 (no string cache) | 0.44 | 2.00× |
+| jiter 0.17.0 (string cache, the default) | 0.48 | 2.21× |
 | msgspec 0.22.0 | 0.53 | 2.42× |
 | orjson 3.12.0 | 0.60 | 2.74× |
 | **fastsimdjson `loads`** | **0.78** | **3.53×** |
@@ -375,7 +401,7 @@ the collector enabled and 1.22× with it disabled (geometric means); without
 the collector, `canada.json`, `mesh.json` and `numbers.json` are ties. yyjson 4.0.6 is left out: it
 returns wrong strings for non-ASCII text. jiter (the parser of pydantic)
 caches strings by default; turning the cache off (`cache_mode=False`) makes it
-slower here (0.44 GB/s).
+slower here.
 
 Parsing is no longer the bottleneck. simdjson alone parses these files at
 3.1 GB/s. It accounts for about a third of the time of `loads`; the rest goes
@@ -390,12 +416,14 @@ and the screen name of the 100 statuses of `twitter.json`:
 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_parse_dark.png">
-  <img src="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_parse.png" width="80%" alt="Reading part of twitter.json: fastsimdjson parse 158 µs, pysimdjson 179, cysimdjson 229, msgspec 336, fastsimdjson loads 861, orjson 1009, json 3922">
+  <img src="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_parse.png" width="80%" alt="Reading part of twitter.json: fastsimdjson parse 158 µs, pysimdjson 179, cysimdjson 229, msgspec 336, fastsimdjson loads 861, orjson 1009, jiter 1281, jiter without its string cache 1592, json 3922">
 </picture>
 
 | method | µs |
 |---|---:|
 | `json.loads` | 3922 |
+| jiter (no string cache) | 1592 |
+| jiter (string cache) | 1281 |
 | orjson | 1009 |
 | fastsimdjson `loads` | 861 |
 | msgspec (typed `Struct`) | 336 |
@@ -449,6 +477,18 @@ times faster than msgspec and 10 times faster than `json`. The comparison was
 run on a processor with AVX-512, which `dumpb` and orjson both use to escape
 strings; other x64 processors use SSE2 and ARM processors NEON.
 
+### Writing NDJSON with `dumpb_many`
+
+The 593,945 events of two hours of [GH Archive](https://www.gharchive.org/)
+(1.87 GB of NDJSON), written back as NDJSON from Python objects. With the
+GIL (Python 3.14.6), one thread: `orjson.dumps` on each record, joined, runs
+at 0.94 GB/s, `dumpb` on each record at 1.07 GB/s, and `dumpb_many` at
+1.41 GB/s. On free-threaded Python 3.14.6t, GB/s:
+
+| threads | 1 | 8 | 32 | 64 |
+|---|---:|---:|---:|---:|
+| `dumpb_many(records, threads=N)` | 1.3 | 6.0 | 11 | 12 |
+
 ### Streams with `loads_many`
 
 20 MB of NDJSON (5268 objects and arrays, one per line), made from the same
@@ -456,12 +496,14 @@ files; best of three runs:
 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_ndjson_dark.png">
-  <img src="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_ndjson.png" width="80%" alt="Reading NDJSON: fastsimdjson parse_many 0.94 GB/s, loads_many 0.38, msgspec decode_lines 0.37, fastsimdjson loads per line 0.33, msgspec decode per line 0.27, orjson per line 0.26, json per line 0.12">
+  <img src="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_ndjson.png" width="80%" alt="Reading NDJSON: fastsimdjson parse_many 0.94 GB/s, loads_many 0.38, msgspec decode_lines 0.37, fastsimdjson loads per line 0.33, msgspec decode per line 0.27, orjson per line 0.26, jiter per line 0.22, jiter without its string cache per line 0.20, json per line 0.12">
 </picture>
 
 | method | ms | GB/s |
 |---|---:|---:|
 | `json.loads` on each line | 169 | 0.12 |
+| jiter on each line (no string cache) | 98 | 0.20 |
+| jiter on each line (string cache) | 90 | 0.22 |
 | orjson on each line | 77 | 0.26 |
 | msgspec `decode` on each line | 74 | 0.27 |
 | fastsimdjson `loads` on each line | 60 | 0.33 |

{fastsimdjson-0.7.0 → fastsimdjson-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fastsimdjson"
-version = "0.7.0"
+version = "0.8.0"
 description = "Fast JSON parsing for Python, built on simdjson"
 readme = "README.md"
 authors = [

{fastsimdjson-0.7.0 → fastsimdjson-0.8.0}/src/fastsimdjson.cpp

@@ -12,6 +12,7 @@
 #include <new>
 #include <condition_variable>
 #include <deque>
+#include <memory>
 #include <mutex>
 #include <string>
 #include <thread>
@@ -2940,6 +2941,11 @@ struct OrjsonEncoder {
         }
       }
     } else {
+#ifdef Py_GIL_DISABLED
+      if (encode_items_locked(o, is_list) < 0) {
+        return -1;
+      }
+#else
       for (Py_ssize_t i = 0;; i++) {
         PyObject *item = is_list ? list_item(o, i)
                          : i < n ? Py_NewRef(PyTuple_GET_ITEM(o, i))
@@ -2954,6 +2960,7 @@ struct OrjsonEncoder {
           return -1;
         }
       }
+#endif
     }
     close(']');
     return 0;
@@ -3010,6 +3017,93 @@ struct OrjsonEncoder {
     return 0;
   }
 
+#ifdef Py_GIL_DISABLED
+  // Free-threaded Python: a dict or list is locked while its items are
+  // encoded, and the items are borrowed when that is safe. Taking references
+  // instead (a snapshot of the items) is slow on many threads: the records
+  // of a list often share their keys and short strings, and the threads then
+  // all update the same reference counts. Encoding an item that may lock
+  // another object or run Python code can suspend the lock (another thread
+  // may then change the container), so such an item is referenced first:
+  // anything but an exact int, float, ASCII str, None, True or False.
+  static bool borrowable(PyObject *v) {
+    PyTypeObject *t = Py_TYPE(v);
+    return (t == &PyUnicode_Type && PyUnicode_IS_COMPACT_ASCII(v)) || t == &PyLong_Type ||
+           t == &PyFloat_Type || v == Py_None || v == Py_True || v == Py_False;
+  }
+
+  // References released when they go out of scope, also when the output
+  // buffer throws std::bad_alloc.
+  struct Refs {
+    PyObject *a, *b;
+    ~Refs() {
+      Py_XDECREF(a);
+      Py_XDECREF(b);
+    }
+  };
+
+  // The lock is released before std::bad_alloc goes further.
+  FSJ_NOINLINE int encode_entries_locked(PyObject *o) {
+    int rc = 0;
+    bool oom = false;
+    Py_BEGIN_CRITICAL_SECTION(o);
+    try {
+      Py_ssize_t pos = 0;
+      PyObject *key, *value;
+      bool first = true;
+      while (rc == 0 && PyDict_Next(o, &pos, &key, &value)) {
+        if (borrowable(key) && borrowable(value)) {
+          rc = encode_entry(key, value, first);
+        } else {
+          Refs r{Py_NewRef(key), Py_NewRef(value)};
+          rc = encode_entry(key, value, first);
+        }
+        first = false;
+      }
+    } catch (const std::bad_alloc &) {
+      oom = true;
+    }
+    Py_END_CRITICAL_SECTION();
+    if (oom) {
+      throw std::bad_alloc();
+    }
+    return rc;
+  }
+
+  // A tuple cannot change: its items live as long as it does.
+  FSJ_NOINLINE int encode_items_locked(PyObject *o, bool is_list) {
+    int rc = 0;
+    if (!is_list) {
+      for (Py_ssize_t i = 0; rc == 0 && i < PyTuple_GET_SIZE(o); i++) {
+        separate(i == 0);
+        rc = encode(PyTuple_GET_ITEM(o, i));
+      }
+      return rc;
+    }
+    bool oom = false;
+    Py_BEGIN_CRITICAL_SECTION(o);
+    try {
+      for (Py_ssize_t i = 0; rc == 0 && i < PyList_GET_SIZE(o); i++) {
+        PyObject *item = PyList_GET_ITEM(o, i);
+        separate(i == 0);
+        if (borrowable(item)) {
+          rc = encode(item);
+        } else {
+          Refs r{Py_NewRef(item), nullptr};
+          rc = encode(item);
+        }
+      }
+    } catch (const std::bad_alloc &) {
+      oom = true;
+    }
+    Py_END_CRITICAL_SECTION();
+    if (oom) {
+      throw std::bad_alloc();
+    }
+    return rc;
+  }
+#endif
+
   // Dict subclasses as dicts (their items, as stored), as with orjson.
   FSJ_NOINLINE int encode_dict(PyObject *o) {
     if (depth >= ORJSON_MAX_DEPTH) { // empty containers count too
@@ -3027,6 +3121,15 @@ struct OrjsonEncoder {
       keys = g_thread_parser.encoded_keys = new (std::nothrow) EncodedKey[ENCODED_KEY_CACHE_SIZE];
     }
     int rc = 0;
+#ifdef Py_GIL_DISABLED
+    if (!(opts & (OPT_NON_STR_KEYS | OPT_SORT_KEYS))) {
+      rc = encode_entries_locked(o);
+      if (rc == 0) {
+        close('}');
+      }
+      return rc;
+    }
+#endif
     // Without borrowed (Python code may run, or another thread), a snapshot
     // holds the keys and values.
     PyObject *items = borrowed ? nullptr : PyDict_Items(o);
@@ -3168,6 +3271,27 @@ struct OrjsonEncoder {
   }
 };
 
+// The flags of option= (None, or an int of orjson's OPT_* flags), as
+// orjson.dumps checks them.
+bool orjson_options(PyObject *option, unsigned long *opts) {
+  *opts = 0;
+  if (option == nullptr || option == Py_None) {
+    return true;
+  }
+  if (!PyLong_Check(option)) {
+    PyErr_SetString(PyExc_TypeError, "Invalid opts");
+    return false;
+  }
+  long v = PyLong_AsLong(option);
+  if ((v == -1 && PyErr_Occurred()) || v < 0 || (unsigned long)v > OPT_ALL) {
+    PyErr_Clear();
+    PyErr_SetString(PyExc_TypeError, "Invalid opts");
+    return false;
+  }
+  *opts = (unsigned long)v;
+  return true;
+}
+
 // dumpb(obj, /, default=None, option=None), as orjson.dumps.
 PyObject *dumpb(PyObject *, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) {
   PyObject *obj = nullptr, *dflt = nullptr, *option = nullptr;
@@ -3196,18 +3320,8 @@ PyObject *dumpb(PyObject *, PyObject *const *args, Py_ssize_t nargs, PyObject *k
     // fails, and becomes the __cause__ of the error.
     e.default_fn = dflt;
   }
-  if (option != nullptr && option != Py_None) {
-    if (!PyLong_Check(option)) {
-      PyErr_SetString(PyExc_TypeError, "Invalid opts");
-      return nullptr;
-    }
-    long v = PyLong_AsLong(option);
-    if ((v == -1 && PyErr_Occurred()) || v < 0 || (unsigned long)v > OPT_ALL) {
-      PyErr_Clear();
-      PyErr_SetString(PyExc_TypeError, "Invalid opts");
-      return nullptr;
-    }
-    e.opts = (unsigned long)v;
+  if (!orjson_options(option, &e.opts)) {
+    return nullptr;
   }
   int rc;
   try {
@@ -3848,7 +3962,16 @@ StreamObject *stream_over(StreamObject *whole, size_t from, size_t to, bool chun
   return s;
 }
 
-struct ParallelRun {
+// Work that pool workers can help with: work() takes pieces of it until
+// none is left. active counts the workers inside work(), guarded by the
+// pool's mutex.
+struct PoolTask {
+  size_t active = 0;
+  virtual void work() = 0;
+  virtual ~PoolTask() = default;
+};
+
+struct ParallelRun : PoolTask {
   StreamObject *whole;
   PyObject *fn; // borrowed, or nullptr
   std::vector<size_t> bounds; // chunk i is [bounds[i], bounds[i + 1])
@@ -3861,7 +3984,6 @@ struct ParallelRun {
   std::vector<Chunk> chunks;
   std::atomic<size_t> next{0};
   std::atomic<size_t> first_failure{SIZE_MAX};
-  size_t active = 0; // pool workers in work(), guarded by the pool's mutex
 
   void note_failure(size_t i) {
     size_t f = first_failure.load();
@@ -3928,7 +4050,7 @@ struct ParallelRun {
 
   // Takes chunks until none is left, letting the garbage collector of
   // other threads run between chunks.
-  void work() {
+  void work() override {
     for (;;) {
       size_t i = next.fetch_add(1);
       if (i >= chunks.size() || i > first_failure.load()) {
@@ -3953,7 +4075,7 @@ struct WorkerPool {
   std::mutex mu;
   std::condition_variable wake; // tasks, or stopping
   std::condition_variable done; // a worker finished a task, or exited
-  std::deque<ParallelRun *> tasks;
+  std::deque<PoolTask *> tasks;
   PyInterpreterState *interp = nullptr;
   size_t workers = 0;
   size_t ready = 0; // workers with a thread state, waiting for tasks
@@ -3971,7 +4093,7 @@ void pool_worker(WorkerPool *pool) {
   }
   pool->done.notify_all();
   for (;;) {
-    ParallelRun *run;
+    PoolTask *run;
     {
       std::unique_lock<std::mutex> lk(pool->mu);
       pool->wake.wait(lk, [pool] { return pool->stopping || !pool->tasks.empty(); });
@@ -4072,6 +4194,31 @@ PyObject *stop_pool(PyObject *, PyObject *) {
   Py_RETURN_NONE;
 }
 
+// Runs task->work() in the calling thread, helped by up to nthreads - 1
+// pool workers; returns when the task is done.
+void run_on_pool(PoolTask *task, size_t nthreads) {
+  WorkerPool *pool = nthreads > 1 ? get_pool(nthreads - 1) : nullptr;
+  if (pool != nullptr) {
+    {
+      std::lock_guard<std::mutex> lk(pool->mu);
+      for (size_t t = 1; t < nthreads; t++) {
+        pool->tasks.push_back(task);
+      }
+    }
+    pool->wake.notify_all();
+  }
+  task->work(); // the calling thread too
+  if (pool != nullptr) {
+    Py_BEGIN_ALLOW_THREADS
+    std::unique_lock<std::mutex> lk(pool->mu);
+    for (auto it = pool->tasks.begin(); it != pool->tasks.end();) {
+      it = *it == task ? pool->tasks.erase(it) : it + 1;
+    }
+    pool->done.wait(lk, [task] { return task->active == 0; });
+    Py_END_ALLOW_THREADS
+  }
+}
+
 #ifndef _WIN32
 // A forked child has none of the workers: forget the pool (and its mutexes,
 // which another thread may have held during the fork).
@@ -4120,26 +4267,7 @@ PyObject *run_stream(StreamObject *whole, PyObject *fn, size_t threads) {
     run.chunks.resize(run.bounds.size() - 1);
     // Starting a thread costs about as much as building 512 KB of documents.
     size_t nthreads = std::min({threads, run.chunks.size(), std::max<size_t>(whole->len >> 19, 1)});
-    WorkerPool *pool = nthreads > 1 ? get_pool(nthreads - 1) : nullptr;
-    if (pool != nullptr) {
-      {
-        std::lock_guard<std::mutex> lk(pool->mu);
-        for (size_t t = 1; t < nthreads; t++) {
-          pool->tasks.push_back(&run);
-        }
-      }
-      pool->wake.notify_all();
-    }
-    run.work(); // the calling thread too
-    if (pool != nullptr) {
-      Py_BEGIN_ALLOW_THREADS
-      std::unique_lock<std::mutex> lk(pool->mu);
-      for (auto it = pool->tasks.begin(); it != pool->tasks.end();) {
-        it = *it == &run ? pool->tasks.erase(it) : it + 1;
-      }
-      pool->done.wait(lk, [&run] { return run.active == 0; });
-      Py_END_ALLOW_THREADS
-    }
+    run_on_pool(&run, nthreads);
     size_t f = run.first_failure.load();
     size_t total = 0;
     for (size_t i = 0; i < run.chunks.size() && i <= f; i++) {
@@ -4387,6 +4515,213 @@ PyObject *map_many(PyObject *, PyObject *args, PyObject *kwargs) {
   return r;
 }
 
+// ---------------------------------------------------------------------------
+// dumpb_many(records, /, default=None, option=None, *, threads=None): the
+// records as NDJSON, each as dumpb writes it, followed by a newline. With
+// threads (free-threaded Python), chunks of records are encoded at once.
+// ---------------------------------------------------------------------------
+
+// Encodes items [a, b) into e.out, one per line. Returns b, or the index of
+// the record that failed, with the exception set.
+size_t encode_lines(OrjsonEncoder &e, PyObject *const *items, size_t a, size_t b) {
+  for (size_t i = a; i < b; i++) {
+    size_t mark = e.out.len;
+    e.depth = e.default_calls = 0;
+#ifndef Py_GIL_DISABLED
+    e.borrowed = true;
+#endif
+    int rc = e.encode(items[i]);
+    if (rc < 0 && e.restart) { // Python code may run: again, without borrowing
+      e.borrowed = e.restart = false;
+      e.out.len = mark;
+      e.depth = e.default_calls = 0;
+      rc = e.encode(items[i]);
+    }
+    if (rc < 0) {
+      return i;
+    }
+    e.out.push_back('\n');
+  }
+  return b;
+}
+
+#ifdef Py_GIL_DISABLED
+struct DumpRun : PoolTask {
+  PyObject *const *items;
+  PyObject *dflt; // borrowed, or nullptr
+  unsigned long opts;
+  std::vector<size_t> bounds; // chunk i is items [bounds[i], bounds[i + 1])
+  struct Chunk {
+    std::unique_ptr<OrjsonEncoder> e; // its output
+    PyObject *type = nullptr, *value = nullptr, *tb = nullptr; // its error
+  };
+  std::vector<Chunk> chunks;
+  std::atomic<size_t> next{0};
+  std::atomic<size_t> first_failure{SIZE_MAX};
+  // Output of the chunks done so far, to size the buffers of the next ones
+  // (growing a buffer copies it).
+  std::atomic<size_t> done_bytes{0};
+  std::atomic<size_t> done_records{0};
+
+  // On an attached thread.
+  void run_chunk(size_t i) {
+    Chunk &c = chunks[i];
+    bool failed;
+    try {
+      c.e.reset(new OrjsonEncoder()); // uses this thread's key cache
+      c.e->default_fn = dflt;
+      c.e->opts = opts;
+      size_t records = bounds[i + 1] - bounds[i];
+      size_t seen = done_records.load(std::memory_order_relaxed);
+      if (seen > 0) {
+        size_t per_record = done_bytes.load(std::memory_order_relaxed) / seen + 1;
+        c.e->out.reserve(per_record * records + per_record * records / 8);
+      }
+      failed = encode_lines(*c.e, items, bounds[i], bounds[i + 1]) < bounds[i + 1];
+      if (!failed) {
+        done_bytes.fetch_add(c.e->out.len, std::memory_order_relaxed);
+        done_records.fetch_add(records, std::memory_order_relaxed);
+      }
+    } catch (const std::bad_alloc &) {
+      PyErr_NoMemory();
+      failed = true;
+    }
+    if (failed) {
+      PyErr_Fetch(&c.type, &c.value, &c.tb);
+      size_t f = first_failure.load();
+      while (i < f && !first_failure.compare_exchange_weak(f, i)) {
+      }
+    }
+  }
+
+  void work() override {
+    for (;;) {
+      size_t i = next.fetch_add(1);
+      if (i >= chunks.size() || i > first_failure.load()) {
+        return;
+      }
+      run_chunk(i);
+      Py_BEGIN_ALLOW_THREADS
+      Py_END_ALLOW_THREADS
+    }
+  }
+};
+
+// Copies the output of each chunk into place, on several threads too (one
+// thread copies about 10 GB/s).
+struct CopyRun : PoolTask {
+  DumpRun *run;
+  char *dst;
+  std::vector<size_t> offsets;
+  std::atomic<size_t> next{0};
+
+  void work() override {
+    for (;;) {
+      size_t i = next.fetch_add(1);
+      if (i >= run->chunks.size()) {
+        return;
+      }
+      const OutBuf &o = run->chunks[i].e->out;
+      memcpy(dst + offsets[i], o.buf, o.len);
+    }
+  }
+};
+
+// The records on several threads, or nullptr with an exception.
+PyObject *dumpb_many_threads(PyObject *const *items, size_t n, PyObject *dflt,
+                             unsigned long opts, size_t threads) {
+  DumpRun run;
+  run.items = items;
+  run.dflt = dflt;
+  run.opts = opts;
+  size_t nchunks = std::min(threads * 8, n);
+  for (size_t k = 0; k <= nchunks; k++) {
+    run.bounds.push_back(n * k / nchunks);
+  }
+  run.chunks.resize(nchunks);
+  run_on_pool(&run, std::min(threads, nchunks));
+  size_t f = run.first_failure.load();
+  PyObject *result = nullptr;
+  if (f == SIZE_MAX) {
+    CopyRun copy;
+    copy.run = &run;
+    size_t total = 0;
+    for (auto &c : run.chunks) {
+      copy.offsets.push_back(total);
+      total += c.e->out.len;
+    }
+    result = PyBytes_FromStringAndSize(nullptr, Py_ssize_t(total));
+    if (result != nullptr) {
+      copy.dst = PyBytes_AS_STRING(result);
+      run_on_pool(&copy, std::min(threads, nchunks));
+    }
+  }
+  // The error of the first record that failed, as without threads.
+  for (size_t i = 0; i < run.chunks.size(); i++) {
+    DumpRun::Chunk &c = run.chunks[i];
+    if (i == f) {
+      PyErr_Restore(c.type, c.value, c.tb);
+    } else {
+      Py_XDECREF(c.type);
+      Py_XDECREF(c.value);
+      Py_XDECREF(c.tb);
+    }
+  }
+  return result;
+}
+#endif
+
+PyObject *dumpb_many(PyObject *, PyObject *args, PyObject *kwargs) {
+  Py_ssize_t threads;
+  bool given;
+  PyObject *rest = take_threads(kwargs, &threads, &given);
+  if (rest == nullptr && PyErr_Occurred()) {
+    return nullptr;
+  }
+  static const char *kwlist[] = {"", "default", "option", nullptr};
+  PyObject *records, *dflt = nullptr, *option = nullptr;
+  int ok = PyArg_ParseTupleAndKeywords(args, rest, "O|OO:dumpb_many",
+                                       const_cast<char **>(kwlist), &records, &dflt, &option);
+  Py_XDECREF(rest);
+  unsigned long opts;
+  if (!ok || !orjson_options(option, &opts)) {
+    return nullptr;
+  }
+  if (opts & OPT_INDENT_2) {
+    PyErr_SetString(PyExc_ValueError, "dumpb_many writes one record per line: OPT_INDENT_2 is not supported");
+    return nullptr;
+  }
+  // A snapshot of the records (a list could change while we encode it).
+  PyObject *tuple = PySequence_Tuple(records);
+  if (tuple == nullptr) {
+    return nullptr;
+  }
+  PyObject *const *items = &PyTuple_GET_ITEM(tuple, 0);
+  size_t n = size_t(PyTuple_GET_SIZE(tuple));
+  PyObject *result = nullptr;
+#ifdef Py_GIL_DISABLED
+  if (given && threads > 1 && n > 1) {
+    result = dumpb_many_threads(items, n, dflt, opts, size_t(threads));
+    Py_DECREF(tuple);
+    return result;
+  }
+#else
+  (void)given;
+#endif
+  OrjsonEncoder e;
+  e.default_fn = dflt;
+  e.opts = opts;
+  try {
+    if (encode_lines(e, items, 0, n) == n) {
+      result = e.out.take_bytes();
+    }
+  } catch (const std::bad_alloc &) {
+    PyErr_NoMemory();
+  }
+  Py_DECREF(tuple);
+  return result;
+}
+
 // Benchmarking helper: run simdjson without building Python objects.
 PyObject *parse_only(PyObject *, PyObject *arg) {
   if (!PyBytes_Check(arg)) {
@@ -4433,9 +4768,15 @@ PyMethodDef methods[] = {
 #ifdef Py_GIL_DISABLED
     {"_stop_pool", stop_pool, METH_NOARGS, "Stop the worker threads (at exit)."},
 #endif
+    {"dumpb_many", reinterpret_cast<PyCFunction>(reinterpret_cast<void (*)(void)>(dumpb_many)),
+     METH_VARARGS | METH_KEYWORDS,
+     "dumpb_many(records, /, default=None, option=None, *, threads=None)\n--\n\n"
+     "The records as NDJSON bytes: each as dumpb writes it, then a newline.\n"
+     "With threads (free-threaded Python), the records are encoded on several threads."},
     {"map_many", reinterpret_cast<PyCFunction>(reinterpret_cast<void (*)(void)>(map_many)),
      METH_VARARGS | METH_KEYWORDS,
-     "map_many(fn, data, *, format, batch_size, threads, lazy): the list of fn(doc) for the "
+     "map_many(fn, data, *, format, batch_size, threads, lazy, fields, default): the list of "
+     "fn(doc) for the "
      "documents of data, with fn called in the threads."},
     {"parse", parse, METH_O,
      "Parse JSON lazily: objects and arrays are returned as read-only views "

{fastsimdjson-0.7.0 → fastsimdjson-0.8.0/src/fastsimdjson.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastsimdjson
-Version: 0.7.0
+Version: 0.8.0
 Summary: Fast JSON parsing for Python, built on simdjson
 Author-email: Daniel Lemire <daniel@lemire.me>
 License-Expression: Apache-2.0
@@ -42,7 +42,8 @@ function is faster still. It also reads streams of documents (NDJSON, JSON
 Lines), on many threads with free-threaded Python, and can extract only the
 fields you need from each document. It writes JSON in two ways: `dumps` returns the same `str` as
 `json.dumps`, and `dumpb` returns the same `bytes` as `orjson.dumps`, as fast
-as orjson.
+as orjson; `dumpb_many` writes NDJSON, on many threads with free-threaded
+Python.
 
 With pip:
 
@@ -158,6 +159,30 @@ serialize dataclasses, `datetime`, `date`, `time`, `UUID`, numpy arrays or
 `OPT_PASSTHROUGH_DATACLASS` and `OPT_PASSTHROUGH_DATETIME` were set, and the
 options that concern only these types are accepted and have no effect.
 
+### `dumpb_many`: NDJSON, on several threads
+
+```python
+data = fastsimdjson.dumpb_many(records)               # b'{...}\n{...}\n'
+data = fastsimdjson.dumpb_many(records, threads=16)   # free-threaded Python
+```
+
+`dumpb_many(records, default=None, option=None, *, threads=None)` returns
+the records (a list, a tuple or any iterable) as NDJSON `bytes`: each record
+as `dumpb` writes it, followed by a newline, so that the output reads back
+with `loads_many(data, format="lines")`. `default` and `option` are those of
+`dumpb`, except `OPT_INDENT_2`, which would spread a record over several
+lines (`ValueError`); `OPT_APPEND_NEWLINE` changes nothing.
+
+On free-threaded Python, `threads=N` writes chunks of records on N threads at
+once (`threads=0` or `None`: one per processor), with the worker threads of
+`map_many`. The output and the errors are those of one thread: when records
+cannot be serialized, the error of the first of them is raised (`default` may
+then have been called on later records, in other threads, and it must be
+safe to call from several threads at once). With the GIL, the calling thread
+does all the work. Like `dumpb`, `dumpb_many` does not crash when other
+threads change the records meanwhile, but the output then reflects some of
+the changes and not others.
+
 ### Files
 
 ```python
@@ -380,7 +405,7 @@ geometric mean over the 22 files (higher is better).
 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_loads_dark.png">
-  <img src="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_loads.png" width="80%" alt="Parsing JSON in Python: fastsimdjson loads 0.78 GB/s, orjson 0.60, msgspec 0.53, jiter 0.48, pysimdjson 0.44, cysimdjson 0.43, ujson 0.37, python-rapidjson 0.24, simplejson 0.23, json 0.22">
+  <img src="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_loads.png" width="80%" alt="Parsing JSON in Python: fastsimdjson loads 0.78 GB/s, orjson 0.60, msgspec 0.53, jiter 0.48, jiter without its string cache 0.44, pysimdjson 0.44, cysimdjson 0.43, ujson 0.37, python-rapidjson 0.24, simplejson 0.23, json 0.22">
 </picture>
 
 | parser | GB/s | vs `json.loads` |
@@ -391,7 +416,8 @@ geometric mean over the 22 files (higher is better).
 | ujson 6.0.0 | 0.37 | 1.66× |
 | cysimdjson 26.27 | 0.43 | 1.96× |
 | pysimdjson 7.0.2 | 0.44 | 1.98× |
-| jiter 0.17.0 | 0.48 | 2.21× |
+| jiter 0.17.0 (no string cache) | 0.44 | 2.00× |
+| jiter 0.17.0 (string cache, the default) | 0.48 | 2.21× |
 | msgspec 0.22.0 | 0.53 | 2.42× |
 | orjson 3.12.0 | 0.60 | 2.74× |
 | **fastsimdjson `loads`** | **0.78** | **3.53×** |
@@ -407,7 +433,7 @@ the collector enabled and 1.22× with it disabled (geometric means); without
 the collector, `canada.json`, `mesh.json` and `numbers.json` are ties. yyjson 4.0.6 is left out: it
 returns wrong strings for non-ASCII text. jiter (the parser of pydantic)
 caches strings by default; turning the cache off (`cache_mode=False`) makes it
-slower here (0.44 GB/s).
+slower here.
 
 Parsing is no longer the bottleneck. simdjson alone parses these files at
 3.1 GB/s. It accounts for about a third of the time of `loads`; the rest goes
@@ -422,12 +448,14 @@ and the screen name of the 100 statuses of `twitter.json`:
 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_parse_dark.png">
-  <img src="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_parse.png" width="80%" alt="Reading part of twitter.json: fastsimdjson parse 158 µs, pysimdjson 179, cysimdjson 229, msgspec 336, fastsimdjson loads 861, orjson 1009, json 3922">
+  <img src="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_parse.png" width="80%" alt="Reading part of twitter.json: fastsimdjson parse 158 µs, pysimdjson 179, cysimdjson 229, msgspec 336, fastsimdjson loads 861, orjson 1009, jiter 1281, jiter without its string cache 1592, json 3922">
 </picture>
 
 | method | µs |
 |---|---:|
 | `json.loads` | 3922 |
+| jiter (no string cache) | 1592 |
+| jiter (string cache) | 1281 |
 | orjson | 1009 |
 | fastsimdjson `loads` | 861 |
 | msgspec (typed `Struct`) | 336 |
@@ -481,6 +509,18 @@ times faster than msgspec and 10 times faster than `json`. The comparison was
 run on a processor with AVX-512, which `dumpb` and orjson both use to escape
 strings; other x64 processors use SSE2 and ARM processors NEON.
 
+### Writing NDJSON with `dumpb_many`
+
+The 593,945 events of two hours of [GH Archive](https://www.gharchive.org/)
+(1.87 GB of NDJSON), written back as NDJSON from Python objects. With the
+GIL (Python 3.14.6), one thread: `orjson.dumps` on each record, joined, runs
+at 0.94 GB/s, `dumpb` on each record at 1.07 GB/s, and `dumpb_many` at
+1.41 GB/s. On free-threaded Python 3.14.6t, GB/s:
+
+| threads | 1 | 8 | 32 | 64 |
+|---|---:|---:|---:|---:|
+| `dumpb_many(records, threads=N)` | 1.3 | 6.0 | 11 | 12 |
+
 ### Streams with `loads_many`
 
 20 MB of NDJSON (5268 objects and arrays, one per line), made from the same
@@ -488,12 +528,14 @@ files; best of three runs:
 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_ndjson_dark.png">
-  <img src="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_ndjson.png" width="80%" alt="Reading NDJSON: fastsimdjson parse_many 0.94 GB/s, loads_many 0.38, msgspec decode_lines 0.37, fastsimdjson loads per line 0.33, msgspec decode per line 0.27, orjson per line 0.26, json per line 0.12">
+  <img src="https://raw.githubusercontent.com/simdjson/fastpysimdjson/main/doc/perf_ndjson.png" width="80%" alt="Reading NDJSON: fastsimdjson parse_many 0.94 GB/s, loads_many 0.38, msgspec decode_lines 0.37, fastsimdjson loads per line 0.33, msgspec decode per line 0.27, orjson per line 0.26, jiter per line 0.22, jiter without its string cache per line 0.20, json per line 0.12">
 </picture>
 
 | method | ms | GB/s |
 |---|---:|---:|
 | `json.loads` on each line | 169 | 0.12 |
+| jiter on each line (no string cache) | 98 | 0.20 |
+| jiter on each line (string cache) | 90 | 0.22 |
 | orjson on each line | 77 | 0.26 |
 | msgspec `decode` on each line | 74 | 0.27 |
 | fastsimdjson `loads` on each line | 60 | 0.33 |

{fastsimdjson-0.7.0 → fastsimdjson-0.8.0}/tests/test_dumps.py

@@ -435,3 +435,115 @@ def test_thread_exit_releases_caches():
     t.start()
     t.join()
     assert sys.getrefcount(key) == before
+
+
+# dumpb_many: each record as dumpb writes it, then a newline.
+
+def _lines(records, **kw):
+    return b"".join(fastsimdjson.dumpb(r, **kw) + b"\n" for r in records)
+
+
+def _error(fn):
+    try:
+        fn()
+    except Exception as e:  # noqa: BLE001
+        return type(e), str(e), type(e.__cause__)
+    return None
+
+
+@pytest.mark.parametrize("seed", range(10))
+def test_dumpb_many_random(seed):
+    rnd = random.Random(seed)
+    records = [random_value(rnd) for _ in range(rnd.randrange(1, 400))]
+    expected = _lines(records)
+    for threads in (None, 1, 4, 7):
+        kw = {} if threads is None else {"threads": threads}
+        assert fastsimdjson.dumpb_many(records, **kw) == expected
+        assert fastsimdjson.dumpb_many(tuple(records), **kw) == expected
+        assert fastsimdjson.dumpb_many(iter(records), **kw) == expected
+    # The output is NDJSON that reads back.
+    assert list(fastsimdjson.loads_many(expected, format="lines")) == \
+        [fastsimdjson.loads(fastsimdjson.dumpb(r)) for r in records]
+
+
+def test_dumpb_many_options():
+    records = [{"b": 1, "a": {1: 2}}, {"z": [3]}] * 50
+    for option in (4 | 32, 32):  # OPT_NON_STR_KEYS | OPT_SORT_KEYS; OPT_SORT_KEYS
+        expected = _error(lambda: _lines(records, option=option)) or _lines(records, option=option)
+        for threads in (1, 4):
+            got = _error(lambda: fastsimdjson.dumpb_many(records, option=option, threads=threads)) or \
+                fastsimdjson.dumpb_many(records, None, option, threads=threads)
+            assert got == expected
+    # One newline per record, with or without OPT_APPEND_NEWLINE.
+    assert fastsimdjson.dumpb_many([1, 2], option=fastsimdjson.OPT_APPEND_NEWLINE) == b"1\n2\n"
+    assert fastsimdjson.dumpb_many([]) == b""
+    assert fastsimdjson.dumpb_many([], threads=4) == b""
+    with pytest.raises(ValueError):
+        fastsimdjson.dumpb_many([1], option=fastsimdjson.OPT_INDENT_2)
+    with pytest.raises(TypeError, match="Invalid opts"):
+        fastsimdjson.dumpb_many([1], option="x")
+    with pytest.raises(TypeError):
+        fastsimdjson.dumpb_many(5)
+    with pytest.raises(TypeError):
+        fastsimdjson.dumpb_many()
+    with pytest.raises(ValueError):
+        fastsimdjson.dumpb_many([1], threads=-1)
+
+
+class _Thing:
+    def __init__(self, n):
+        self.n = n
+
+
+def test_dumpb_many_default_and_errors():
+    records = [{"i": i, "t": _Thing(i)} for i in range(3000)]
+
+    def default(o):
+        if isinstance(o, _Thing):
+            if o.n in (1700, 2500):
+                raise ValueError(f"bad {o.n}")
+            return o.n * 2
+        raise TypeError
+
+    good = records[:1700]
+    for threads in (None, 1, 4, 16):
+        kw = {} if threads is None else {"threads": threads}
+        assert fastsimdjson.dumpb_many(good, default=default, **kw) == _lines(good, default=default)
+        # The error of the first record that fails, as dumpb raises it (with
+        # default's exception as its cause).
+        got = _error(lambda: fastsimdjson.dumpb_many(records, default, **kw))
+        assert got == _error(lambda: fastsimdjson.dumpb(records[1700], default=default))
+        assert got[2] is ValueError
+        bad = [1, 2, {"x": object()}, 3, [object()]]
+        assert _error(lambda: fastsimdjson.dumpb_many(bad, **kw)) == \
+            _error(lambda: fastsimdjson.dumpb(bad[2]))
+
+
+def test_dumpb_many_under_mutation():
+    # Another thread changes the records while they are written: the output
+    # is still one valid document per record (free-threaded Python).
+    import threading
+
+    records = [{"i": i, "l": [i, "é", {"k": i}], "d": {"x": [1, 2]}} for i in range(3000)]
+    stop = threading.Event()
+
+    def mutate():
+        rnd = random.Random(0)
+        while not stop.is_set():
+            r = records[rnd.randrange(len(records))]
+            r["l"].append(rnd.random())
+            if len(r["l"]) > 6:
+                r["l"].clear()
+            r["d"] = {"y": "é" * rnd.randrange(4), "z": [None]}
+            r.pop("i", None) if rnd.random() < 0.5 else r.update(i=rnd.randrange(9))
+
+    t = threading.Thread(target=mutate)
+    t.start()
+    try:
+        for _ in range(20):
+            out = fastsimdjson.dumpb_many(records, threads=8)
+            docs = list(fastsimdjson.loads_many(out, format="lines"))
+            assert len(docs) == len(records)
+    finally:
+        stop.set()
+        t.join()