fastsimdjson 0.3.0__tar.gz → 0.4.0__tar.gz

{fastsimdjson-0.3.0/src/fastsimdjson.egg-info → fastsimdjson-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastsimdjson
-Version: 0.3.0
+Version: 0.4.0
 Summary: Fast JSON parsing for Python, built on simdjson
 Author-email: Daniel Lemire <daniel@lemire.me>
 License-Expression: Apache-2.0
@@ -437,10 +437,13 @@ its time.
 
 * The simdjson parser and the key and string caches are thread-local.
   `release()` frees the parser and the cached strings retained by the calling
-  thread. A parser that grows past 64 MB is freed on its own at the end of
-  that call; its caches stay. A thread that exits without `release()` leaves
-  its cached strings behind.
+  thread, and they are freed when a Python thread exits. A parser that grows
+  past 64 MB is freed on its own at the end of that call; its caches stay.
 * The module is marked free-threading compatible (`Py_MOD_GIL_NOT_USED` on
   Python 3.13 and newer), so importing it on a free-threaded build does not
-  re-enable the GIL. On a free-threaded build, `bytearray` and `memoryview`
-  inputs are copied before parsing. Subinterpreters are not supported.
+  re-enable the GIL. It is tested with many threads parsing, serializing and
+  sharing views and stream iterators on free-threaded Python 3.14 and 3.15.
+  On a free-threaded build, `bytearray` and `memoryview` inputs are copied
+  before parsing, and `dumps` and `dumpb` hold references to the items of the
+  containers they serialize, since other threads may change them.
+  Subinterpreters are not supported.

{fastsimdjson-0.3.0 → fastsimdjson-0.4.0}/README.md

@@ -406,10 +406,13 @@ its time.
 
 * The simdjson parser and the key and string caches are thread-local.
   `release()` frees the parser and the cached strings retained by the calling
-  thread. A parser that grows past 64 MB is freed on its own at the end of
-  that call; its caches stay. A thread that exits without `release()` leaves
-  its cached strings behind.
+  thread, and they are freed when a Python thread exits. A parser that grows
+  past 64 MB is freed on its own at the end of that call; its caches stay.
 * The module is marked free-threading compatible (`Py_MOD_GIL_NOT_USED` on
   Python 3.13 and newer), so importing it on a free-threaded build does not
-  re-enable the GIL. On a free-threaded build, `bytearray` and `memoryview`
-  inputs are copied before parsing. Subinterpreters are not supported.
+  re-enable the GIL. It is tested with many threads parsing, serializing and
+  sharing views and stream iterators on free-threaded Python 3.14 and 3.15.
+  On a free-threaded build, `bytearray` and `memoryview` inputs are copied
+  before parsing, and `dumps` and `dumpb` hold references to the items of the
+  containers they serialize, since other threads may change them.
+  Subinterpreters are not supported.

{fastsimdjson-0.3.0 → fastsimdjson-0.4.0}/pyproject.toml

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

{fastsimdjson-0.3.0 → fastsimdjson-0.4.0}/src/fastsimdjson.cpp

@@ -147,6 +147,7 @@ struct ThreadParser {
   KeyCacheEntry key_cache[KEY_CACHE_SIZE]{};
   KeyCacheEntry value_cache[KEY_CACHE_SIZE]{};
   EncodedKey *encoded_keys = nullptr; // allocated on first use by dumpb
+  bool cleanup_registered = false;    // see register_thread_cleanup
   void clear_encoded_keys() {
     if (encoded_keys != nullptr) {
       for (size_t i = 0; i < ENCODED_KEY_CACHE_SIZE; i++) {
@@ -170,6 +171,50 @@ struct ThreadParser {
 };
 thread_local ThreadParser g_thread_parser;
 
+// Frees this thread's parser, documents and caches (release()).
+void release_thread_state() {
+  delete g_thread_parser.ptr;
+  g_thread_parser.ptr = nullptr;
+  delete g_thread_parser.spare;
+  g_thread_parser.spare = nullptr;
+  clear_cache(g_thread_parser.key_cache);
+  clear_cache(g_thread_parser.value_cache);
+  g_thread_parser.clear_encoded_keys();
+}
+
+// The thread-local destructor runs after Python has deleted the thread
+// state of an exiting thread, too late to release the cached strings. So
+// each thread puts a capsule in its thread state's dict: Python clears that
+// dict while the thread state is still valid, and the capsule's destructor
+// releases the caches then. It does so only on its own thread (a thread
+// state can be cleared from another thread, at finalization).
+const char THREAD_CAPSULE[] = "fastsimdjson.thread_state";
+
+void thread_cleanup(PyObject *capsule) {
+  if (PyCapsule_GetPointer(capsule, THREAD_CAPSULE) == &g_thread_parser) {
+    g_thread_parser.cleanup_registered = false;
+    if (caches_can_decref()) {
+      release_thread_state();
+    }
+  }
+}
+
+FSJ_NOINLINE void register_thread_cleanup_slow() {
+  g_thread_parser.cleanup_registered = true;
+  PyObject *dict = PyThreadState_GetDict(); // borrowed
+  PyObject *capsule = dict ? PyCapsule_New(&g_thread_parser, THREAD_CAPSULE, thread_cleanup) : nullptr;
+  if (capsule == nullptr || PyDict_SetItemString(dict, THREAD_CAPSULE, capsule) < 0) {
+    PyErr_Clear(); // without it, the caches of an exiting thread leak, as before
+  }
+  Py_XDECREF(capsule);
+}
+
+inline void register_thread_cleanup() {
+  if (!g_thread_parser.cleanup_registered) {
+    register_thread_cleanup_slow();
+  }
+}
+
 inline uint64_t load_u64(const char *p) {
   uint64_t v;
   memcpy(&v, p, 8);
@@ -284,6 +329,7 @@ inline PyObject *make_str(const char *s, size_t len) {
 }
 
 inline void cache_store(KeyCacheEntry &entry, PyObject *u, size_t len, const KeyWords &w) {
+  register_thread_cleanup(); // the entry holds a reference: free it at thread exit
   Py_INCREF(u);
   Py_XDECREF(entry.key);
   entry.key = u;
@@ -593,6 +639,7 @@ bool ensure_parser() {
   if (g_thread_parser.ptr != nullptr) {
     return true;
   }
+  register_thread_cleanup();
   g_thread_parser.ptr = new (std::nothrow) parser();
   if (g_thread_parser.ptr == nullptr) {
     PyErr_NoMemory();
@@ -2698,6 +2745,7 @@ struct OrjsonEncoder {
       return -1;
     }
     if (keys == nullptr) {
+      register_thread_cleanup();
       keys = g_thread_parser.encoded_keys = new (std::nothrow) EncodedKey[ENCODED_KEY_CACHE_SIZE];
     }
     int rc = 0;
@@ -3428,12 +3476,7 @@ PyObject *parse_only(PyObject *, PyObject *arg) {
 }
 
 PyObject *release(PyObject *, PyObject *) {
-  release_parser();
-  delete g_thread_parser.spare;
-  g_thread_parser.spare = nullptr;
-  clear_cache(g_thread_parser.key_cache);
-  clear_cache(g_thread_parser.value_cache);
-  g_thread_parser.clear_encoded_keys();
+  release_thread_state();
   Py_RETURN_NONE;
 }
 

{fastsimdjson-0.3.0 → fastsimdjson-0.4.0/src/fastsimdjson.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastsimdjson
-Version: 0.3.0
+Version: 0.4.0
 Summary: Fast JSON parsing for Python, built on simdjson
 Author-email: Daniel Lemire <daniel@lemire.me>
 License-Expression: Apache-2.0
@@ -437,10 +437,13 @@ its time.
 
 * The simdjson parser and the key and string caches are thread-local.
   `release()` frees the parser and the cached strings retained by the calling
-  thread. A parser that grows past 64 MB is freed on its own at the end of
-  that call; its caches stay. A thread that exits without `release()` leaves
-  its cached strings behind.
+  thread, and they are freed when a Python thread exits. A parser that grows
+  past 64 MB is freed on its own at the end of that call; its caches stay.
 * The module is marked free-threading compatible (`Py_MOD_GIL_NOT_USED` on
   Python 3.13 and newer), so importing it on a free-threaded build does not
-  re-enable the GIL. On a free-threaded build, `bytearray` and `memoryview`
-  inputs are copied before parsing. Subinterpreters are not supported.
+  re-enable the GIL. It is tested with many threads parsing, serializing and
+  sharing views and stream iterators on free-threaded Python 3.14 and 3.15.
+  On a free-threaded build, `bytearray` and `memoryview` inputs are copied
+  before parsing, and `dumps` and `dumpb` hold references to the items of the
+  containers they serialize, since other threads may change them.
+  Subinterpreters are not supported.

{fastsimdjson-0.3.0 → fastsimdjson-0.4.0}/tests/test_dumps.py

@@ -415,3 +415,23 @@ def test_dumpb_matches_orjson_cases():
     for obj, option, _ in ORJSON_CASES:
         assert orjson_outcome(fastsimdjson.dumpb, obj, option=option) == \
             orjson_outcome(orjson.dumps, obj, option=option), (obj, option)
+
+
+def test_thread_exit_releases_caches():
+    # A key that enters dumpb's key cache (seen twice) is referenced by the
+    # cache; when the thread exits, its caches are released.
+    import sys
+    import threading
+
+    key = "".join(["thread", "-exit-", "key"])  # not interned
+    before = sys.getrefcount(key)
+
+    def work():
+        for _ in range(3):
+            assert fastsimdjson.dumpb({key: 1}) == b'{"thread-exit-key":1}'
+        fastsimdjson.loads(b'{"a": "b"}')
+
+    t = threading.Thread(target=work)
+    t.start()
+    t.join()
+    assert sys.getrefcount(key) == before