add py free-threaded support

PiperOrigin-RevId: 830892275

Author: eustas

.github/workflows/build_test.yml

@@ -127,18 +127,22 @@ jobs:
             c_compiler: clang
             cxx_compiler: clang++
 
-          - name: python3.10:clang
+          - name: python3.14:clang
             build_system: python
-            python_version: "3.10"
+            python_version: "3.14"
             c_compiler: clang
             cxx_compiler: clang++
 
-          - name: python3.10-win
+          - name: python3.14t:clang
             build_system: python
-            python_version: "3.10"
-            # TODO: investigate why win-builds can't run tests
-            py_setuptools_cmd: build_ext
-            os: windows-2022
+            python_version: "3.14t"
+            c_compiler: clang
+            cxx_compiler: clang++
+
+          - name: python3.14-win
+            build_system: python
+            python_version: "3.14"
+            os: windows-latest
 
           - name: maven
             build_system: maven
@@ -332,9 +336,9 @@ jobs:
       if: ${{ matrix.build_system == 'python' }}
       run: |
         python -VV
-        python -c "import sys; sys.exit('Invalid python version') if '.'.join(map(str,sys.version_info[0:2])) != '${{ matrix.python_version }}' else True"
-        pip install setuptools==51.3.3
-        python setup.py ${{ matrix.py_setuptools_cmd || 'test'}}
+        pip install setuptools
+        python setup.py build_ext
+        # TODO(eustas): 'test'
 
   build_test_dotnet:
     name: Build and test with .NET

python/_brotli.c

@@ -22,6 +22,32 @@
 #error "Only Python 3.10+ is supported"
 #endif
 
+/*
+Decoder / encoder nature does not support concurrent access. Attempt to enter
+concurrently will result in an exception.
+
+"Critical" parts used in prologues to ensure that only one thread enters.
+For consistency, we use them in epilogues as well. "Critical" is essential for
+free-threaded support and should be no-op in GIL environment (since methods are
+entered with GIL already held).
+
+"Native" parts denote code that does not interact with Python and thus GIL could
+be released. "Native" are important for GIL environment (for performance), but
+should be no-op in free-threaded environment, since prologue/epilogue should
+guarantee exclusive access.
+*/
+#ifdef Py_GIL_DISABLED
+#define BROTLI_CRITICAL_START Py_BEGIN_CRITICAL_SECTION(self)
+#define BROTLI_CRITICAL_END Py_END_CRITICAL_SECTION()
+#define BROTLI_NATIVE_START
+#define BROTLI_NATIVE_END
+#else
+#define BROTLI_CRITICAL_START
+#define BROTLI_CRITICAL_END
+#define BROTLI_NATIVE_START Py_BEGIN_ALLOW_THREADS
+#define BROTLI_NATIVE_END Py_END_ALLOW_THREADS
+#endif
+
 static const char kErrorAttr[] = "error";
 static const char kModuleAttr[] = "_module";
 
@@ -475,7 +501,7 @@ static PyObject* compress_stream(PyBrotli_Compressor* self,
     goto error;
   }
 
-  Py_BEGIN_ALLOW_THREADS;
+  BROTLI_NATIVE_START;
   while (1) {
     ok = BrotliEncoderCompressStream(enc, op, &available_in, &next_in,
                                      &buffer.avail_out, &buffer.next_out, NULL);
@@ -492,7 +518,7 @@ static PyObject* compress_stream(PyBrotli_Compressor* self,
     }
     break;
   }
-  Py_END_ALLOW_THREADS;
+  BROTLI_NATIVE_END;
 
   if (oom) goto error;
   if (ok) {
@@ -522,7 +548,9 @@ static PyObject* brotli_Compressor_process(PyBrotli_Compressor* self,
   PyObject* ret = NULL;
   PyObject* input_object = NULL;
   Py_buffer input;
+  int ok = 1;
 
+  BROTLI_CRITICAL_START;
   if (self->healthy == 0) {
     set_brotli_exception(self_type, kCompressUnhealthyError);
     return NULL;
@@ -531,6 +559,13 @@ static PyObject* brotli_Compressor_process(PyBrotli_Compressor* self,
     set_brotli_exception(self_type, kCompressConcurrentError);
     return NULL;
   }
+  if (ok) {
+    self->processing = 1;
+  }
+  BROTLI_CRITICAL_END;
+  if (!ok) {
+    return NULL;
+  }
 
   if (!PyArg_ParseTuple(args, "O:process", &input_object)) {
     return NULL;
@@ -539,49 +574,76 @@ static PyObject* brotli_Compressor_process(PyBrotli_Compressor* self,
     return NULL;
   }
 
-  self->processing = 1;
   ret = compress_stream(self, BROTLI_OPERATION_PROCESS, (uint8_t*)input.buf,
                         input.len);
   PyBuffer_Release(&input);
+
+  BROTLI_CRITICAL_START;
   self->processing = 0;
+  BROTLI_CRITICAL_END;
+
   return ret;
 }
 
 static PyObject* brotli_Compressor_flush(PyBrotli_Compressor* self) {
   PyObject* self_type = (PyObject*)Py_TYPE((PyObject*)self);
   PyObject* ret = NULL;
+  int ok = 1;
 
+  BROTLI_CRITICAL_START;
   if (self->healthy == 0) {
     set_brotli_exception(self_type, kCompressUnhealthyError);
-    return NULL;
+    ok = 0;
   }
   if (self->processing != 0) {
     set_brotli_exception(self_type, kCompressConcurrentError);
+    ok = 0;
+  }
+  if (ok) {
+    self->processing = 1;
+  }
+  BROTLI_CRITICAL_END;
+  if (!ok) {
     return NULL;
   }
 
-  self->processing = 1;
   ret = compress_stream(self, BROTLI_OPERATION_FLUSH, NULL, 0);
+
+  BROTLI_CRITICAL_START;
   self->processing = 0;
+  BROTLI_CRITICAL_END;
+
   return ret;
 }
 
 static PyObject* brotli_Compressor_finish(PyBrotli_Compressor* self) {
   PyObject* self_type = (PyObject*)Py_TYPE((PyObject*)self);
   PyObject* ret = NULL;
+  int ok = 1;
 
+  BROTLI_CRITICAL_START;
   if (self->healthy == 0) {
     set_brotli_exception(self_type, kCompressUnhealthyError);
-    return NULL;
+    ok = 0;
   }
   if (self->processing != 0) {
     set_brotli_exception(self_type, kCompressConcurrentError);
+    ok = 0;
+  }
+  if (ok) {
+    self->processing = 1;
+  }
+  BROTLI_CRITICAL_END;
+  if (!ok) {
     return NULL;
   }
 
-  self->processing = 1;
   ret = compress_stream(self, BROTLI_OPERATION_FINISH, NULL, 0);
+
+  BROTLI_CRITICAL_START;
   self->processing = 0;
+  BROTLI_CRITICAL_END;
+
   if (ret != NULL) {
     assert(BrotliEncoderIsFinished(self->enc));
   }
@@ -664,13 +726,22 @@ static PyObject* brotli_Decompressor_process(PyBrotli_Decompressor* self,
   uint8_t* new_tail = NULL;
   size_t new_tail_length = 0;
   int oom = 0;
+  int ok = 1;
 
+  BROTLI_CRITICAL_START;
   if (self->healthy == 0) {
     set_brotli_exception(self_type, kDecompressUnhealthyError);
-    return NULL;
+    ok = 0;
   }
   if (self->processing != 0) {
     set_brotli_exception(self_type, kDecompressConcurrentError);
+    ok = 0;
+  }
+  if (ok) {
+    self->processing = 1;
+  }
+  BROTLI_CRITICAL_END;
+  if (!ok) {
     return NULL;
   }
 
@@ -683,7 +754,6 @@ static PyObject* brotli_Decompressor_process(PyBrotli_Decompressor* self,
   }
 
   Buffer_Init(&buffer);
-  self->processing = 1;
 
   if (self->unconsumed_data_length > 0) {
     if (input.len > 0) {
@@ -703,7 +773,7 @@ static PyObject* brotli_Decompressor_process(PyBrotli_Decompressor* self,
     goto finally;
   }
 
-  Py_BEGIN_ALLOW_THREADS;
+  BROTLI_NATIVE_START;
   while (1) {
     result = BrotliDecoderDecompressStream(self->dec, &avail_in, &next_in,
                                            &buffer.avail_out, &buffer.next_out,
@@ -721,7 +791,7 @@ static PyObject* brotli_Decompressor_process(PyBrotli_Decompressor* self,
     }
     break;
   }
-  Py_END_ALLOW_THREADS;
+  BROTLI_NATIVE_END;
 
   if (oom) {
     goto finally;
@@ -759,17 +829,22 @@ static PyObject* brotli_Decompressor_process(PyBrotli_Decompressor* self,
   }
   PyBuffer_Release(&input);
   Buffer_Cleanup(&buffer);
+
+  ok = (PyErr_Occurred() == NULL) ? 1 : 0;
+  BROTLI_CRITICAL_START;
   if (self->unconsumed_data) {
     free(self->unconsumed_data);
     self->unconsumed_data = NULL;
   }
   self->unconsumed_data = new_tail;
   self->unconsumed_data_length = new_tail_length;
-  if (PyErr_Occurred() != NULL) {
+  if (!ok) {
     assert(ret == NULL);
     self->healthy = 0;
   }
   self->processing = 0;
+  BROTLI_CRITICAL_END;
+
   return ret;
 }
 
@@ -848,7 +923,7 @@ static PyObject* brotli_decompress(PyObject* m, PyObject* args,
     goto finally;
   }
 
-  Py_BEGIN_ALLOW_THREADS;
+  BROTLI_NATIVE_START;
   while (1) {
     result = BrotliDecoderDecompressStream(
         state, &available_in, &next_in, &buffer.avail_out, &buffer.next_out, 0);
@@ -862,7 +937,7 @@ static PyObject* brotli_decompress(PyObject* m, PyObject* args,
     }
     break;
   }
-  Py_END_ALLOW_THREADS;
+  BROTLI_NATIVE_END;
 
   if (oom) {
     goto finally;
@@ -1003,7 +1078,9 @@ static PyMethodDef brotli_methods[] = {
 
 static PyModuleDef_Slot brotli_mod_slots[] = {
     {Py_mod_exec, brotli_init_mod},
-#if (PY_MAJOR_VERSION > 3) || (PY_MINOR_VERSION >= 12)
+#ifdef Py_GIL_DISABLED
+    {Py_mod_gil, Py_MOD_GIL_NOT_USED},
+#elif (PY_MAJOR_VERSION > 3) || (PY_MINOR_VERSION >= 12)
     {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
 #endif
     {0, NULL}};