gh-111623 Serialize tuples with sub interpreters

Lib/test/test__xxsubinterpreters.py

@@ -105,6 +105,7 @@ def test_default_shareables(self):
                 True,
                 False,
                 100.0,
+                (),
                 ]
         for obj in shareables:
             with self.subTest(obj):
@@ -195,6 +196,29 @@ def test_bool(self):
     def test_float(self):
         self._assert_values([0.0, 1.1, -1.0, 0.12345678, -0.12345678])
 
+    def test_tuple(self):
+        self._assert_values([(), (1,), ("hello", "world", ), (1, True, "hello")])
+        # Test nesting
+        self._assert_values([((1,),), ((1, 2), (3, 4)), ((1, 2), (3, 4), (5, 6))])
+
+    def test_tuples_containing_non_shareable_types(self):
+        non_shareables = [
+                Exception(),
+                object(),
+        ]
+        for s in non_shareables:
+            value = tuple([0, 1., s])
+            with self.subTest(repr(value)):
+                # XXX Assert the NotShareableError when it is exported
+                with self.assertRaises(Exception):
+                     _testinternalcapi.get_crossinterp_data(value)
+            # Check nested as well
+            value = tuple([0, 1., (s,)])
+            with self.subTest("nested " + repr(value)):
+                # XXX Assert the NotShareableError when it is exported
+                with self.assertRaises(Exception):
+                     _testinternalcapi.get_crossinterp_data(value)
+
 
 class ModuleTests(TestBase):
 

Lib/test/test_interpreters.py

@@ -781,6 +781,7 @@ def test_default_shareables(self):
                 True,
                 False,
                 100.0,
+                (),
                 ]
         for obj in shareables:
             with self.subTest(obj):

Misc/NEWS.d/next/Core and Builtins/2023-11-02-15-00-57.gh-issue-111623.BZxYc8.rst

@@ -0,0 +1,2 @@
+Support for sharing tuples between interpreters using the cross-interpreter
+API

Python/crossinterp.c

@@ -713,6 +713,69 @@ _bool_shared(PyThreadState *tstate, PyObject *obj,
     return 0;
 }
 
+struct _shared_tuple_data {
+    Py_ssize_t len;
+    _PyCrossInterpreterData ** data;
+};
+
+static PyObject *
+_new_tuple_object(_PyCrossInterpreterData *data)
+{
+    struct _shared_tuple_data *shared = (struct _shared_tuple_data *)(data->data);
+    PyObject *tuple = PyTuple_New(shared->len);
+
+    for (Py_ssize_t i = 0; i < shared->len; i++) {
+        PyObject *item = _PyCrossInterpreterData_NewObject(shared->data[i]);
+        PyTuple_SET_ITEM(tuple, i, item);
+    }
+    return tuple;
+}
+
+static void
+_tuple_shared_free(void* data)
+{
+    struct _shared_tuple_data *shared = (struct _shared_tuple_data *)(data);
+    for (Py_ssize_t i = 0; i < shared->len; i++) {
+        _PyCrossInterpreterData_Release(shared->data[i]);
+    }
+    PyMem_Free(shared->data);
+    PyMem_RawFree(shared);
+}
+
+static int
+_tuple_shared(PyThreadState *tstate, PyObject *obj,
+             _PyCrossInterpreterData *data)
+{
+    if (_PyCrossInterpreterData_InitWithSize(
+            data, tstate->interp, sizeof(struct _shared_tuple_data), obj,
+            _new_tuple_object
+            ) < 0)
+    {
+        return -1;
+    }
+    struct _shared_tuple_data *shared = (struct _shared_tuple_data *)data->data;
+    shared->len = PyTuple_GET_SIZE(obj);
+    shared->data = (_PyCrossInterpreterData **) PyMem_Calloc(shared->len, sizeof(_PyCrossInterpreterData *));
+    if (shared->data == NULL) {
+        PyErr_Format(PyExc_MemoryError, "not enough memory");
+        return -1;
+    }
+
+    for (Py_ssize_t i = 0; i < shared->len; i++) {
+        shared->data[i] = _PyCrossInterpreterData_New();
+        if (shared->data[i] == NULL){
+            PyMem_Free(shared->data);
+            return -1; // PyErr_NoMemory already set
+        }
+        PyObject *item = PyTuple_GET_ITEM(obj, i);
+        if (_PyObject_GetCrossInterpreterData(item, shared->data[i]) != 0) {
+            return -1;
+        }
+    }
+    data->free = _tuple_shared_free;
+    return 0;
+}
+
 static void
 _register_builtins_for_crossinterpreter_data(struct _xidregistry *xidregistry)
 {
@@ -745,6 +808,11 @@ _register_builtins_for_crossinterpreter_data(struct _xidregistry *xidregistry)
     if (_xidregistry_add_type(xidregistry, &PyFloat_Type, _float_shared) != 0) {
         Py_FatalError("could not register float for cross-interpreter sharing");
     }
+
+    // tuple
+    if (_xidregistry_add_type(xidregistry, &PyTuple_Type, _tuple_shared) != 0) {
+        Py_FatalError("could not register tuple for cross-interpreter sharing");
+    }
 }
 
 /* registry lifecycle */