Freethreading surface early work

Author: oddbookworm

examples/multithreaded_surface.py

@@ -0,0 +1,70 @@
+import pygame
+import threading
+import random
+
+from time import perf_counter
+
+start = perf_counter()
+
+pygame.init()
+
+WIDTH, HEIGHT = 100, 100
+NUM_THREADS = 10
+surface = pygame.Surface((WIDTH, HEIGHT))
+surface.fill("black")
+
+LERP_OFFSET = 0.01
+
+
+def get_random_color() -> pygame.Color:
+    r = random.randint(0, 255)
+    g = random.randint(0, 255)
+    b = random.randint(0, 255)
+    a = 255
+    return pygame.Color(r, g, b, a)
+
+
+def multithreaded_func(
+    surf: pygame.Surface, target_pixel: tuple[int, int], target_color: pygame.Color
+) -> None:
+    lerp_distance = 0
+
+    original_color = surf.get_at(target_pixel)
+
+    while (surf.get_at(target_pixel) != target_color) and lerp_distance < 1:
+        lerp_distance += LERP_OFFSET
+        new_color = original_color.lerp(target_color, lerp_distance)
+        surf.set_at(target_pixel, new_color)
+
+
+pixels = [(col, row) for col in range(WIDTH) for row in range(HEIGHT)]
+
+colors = [get_random_color() for _ in range(WIDTH * HEIGHT)]
+
+args = [(pixel, colors[i]) for i, pixel in enumerate(pixels)]
+batches = {
+    i: args[i * NUM_THREADS : (i + 1) * NUM_THREADS]
+    for i in range(WIDTH * HEIGHT // NUM_THREADS)
+}
+
+for batch in batches.values():
+    threads: list[threading.Thread] = []
+    for pixel, color in batch:
+        new_thread = threading.Thread(
+            target=multithreaded_func, args=(surface, pixel, color)
+        )
+        new_thread.start()
+        threads.append(new_thread)
+
+    while any([t.is_alive() for t in threads]):
+        continue
+
+pygame.image.save(pygame.transform.scale_by(surface, 10), "out.png")
+
+end = perf_counter()
+
+print(f"time taken: {end - start}")
+
+for pixel, color in zip(pixels, colors):
+    surface.set_at(pixel, color)
+pygame.image.save(pygame.transform.scale_by(surface, 10), "comparison.png")

pyproject.toml

@@ -56,7 +56,7 @@ requires = [
   "meson-python<=0.17.1",
   "meson<=1.7.0",
   "ninja<=1.12.1",
-  "cython<=3.0.11",
+  "cython<=3.1.0a1",
   "sphinx<=8.1.3",
   "sphinx-autoapi<=3.3.2",
 ]

src_c/color.c

@@ -808,7 +808,9 @@ _color_lerp(pgColorObject *self, PyObject *args, PyObject *kw)
         return NULL;
     }
 
-    if (amt < 0 || amt > 1) {
+    static const double TOLERANCE = 1e-6;
+
+    if (amt < -TOLERANCE || amt > (1.0 + TOLERANCE)) {
         return RAISE(PyExc_ValueError, "Argument 2 must be in range [0, 1]");
     }
 

src_c/include/_pygame.h

@@ -320,9 +320,28 @@ typedef struct {
     PyObject *weakreflist;
     PyObject *locklist;
     PyObject *dependency;
+#if PY_MINOR_VERSION >= 13 && Py_GIL_DISABLED
+    PyMutex mutex;
+#endif
 } pgSurfaceObject;
 #define pgSurface_AsSurface(x) (((pgSurfaceObject *)x)->surf)
 
+#if PY_MINOR_VERSION >= 13 && Py_GIL_DISABLED
+#define LOCK_pgSurfaceObject(pgSurfacePtr)           \
+    PyMutex_Lock(&(((pgSurfaceObject *)pgSurfacePtr) \
+                       ->mutex));  // printf("Locking mutex\n");
+#else
+#define LOCK_pgSurfaceObject(pgSurfacePtr)
+#endif
+
+#if PY_MINOR_VERSION >= 13 && Py_GIL_DISABLED
+#define UNLOCK_pgSurfaceObject(pgSurfacePtr)           \
+    PyMutex_Unlock(&(((pgSurfaceObject *)pgSurfacePtr) \
+                         ->mutex));  // printf("Unlocking mutex\n");
+#else
+#define UNLOCK_pgSurfaceObject(pgSurfacePtr)
+#endif
+
 #ifndef PYGAMEAPI_SURFACE_INTERNAL
 #define pgSurface_Type (*(PyTypeObject *)PYGAMEAPI_GET_SLOT(surface, 0))
 
@@ -617,6 +636,18 @@ PYGAMEAPI_EXTERN_SLOTS(geometry);
         }                                                               \
     }
 
+#if Py_GIL_DISABLED
+#define DISABLE_GIL_SINGLE_INITIALIZATION(module, name)              \
+    if (PyUnstable_Module_SetGIL(module, Py_MOD_GIL_NOT_USED) < 0) { \
+        Py_DECREF(module);                                           \
+        return NULL;                                                 \
+    }                                                                \
+    printf("%s was compiled wtih GIL disabled\n", name);
+#else
+#define DISABLE_GIL_SINGLE_INITIALIZATION(module, name) \
+    printf("%s was compiled with GIL enabled\n", name);
+#endif
+
 static PG_INLINE PyObject *
 pg_tuple_couple_from_values_int(int val1, int val2)
 {

src_c/surface.c

@@ -392,6 +392,9 @@ surface_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
         self->weakreflist = NULL;
         self->dependency = NULL;
         self->locklist = NULL;
+#if PY_VERSION_MINOR >= 13 && Py_GIL_DISABLED
+        self->mutex[0] = 0;
+#endif
     }
     return (PyObject *)self;
 }
@@ -725,8 +728,9 @@ surf_get_at(PyObject *self, PyObject *position)
                      "position must be a sequence of two numbers");
     }
 
-    if (x < 0 || x >= surf->w || y < 0 || y >= surf->h)
+    if (x < 0 || x >= surf->w || y < 0 || y >= surf->h) {
         return RAISE(PyExc_IndexError, "pixel index out of range");
+    }
 
     PG_PixelFormat *format;
     SDL_Palette *palette;
@@ -735,11 +739,18 @@ surf_get_at(PyObject *self, PyObject *position)
     }
     int bpp = PG_FORMAT_BytesPerPixel(format);
 
-    if (bpp < 1 || bpp > 4)
+    if (bpp < 1 || bpp > 4) {
         return RAISE(PyExc_RuntimeError, "invalid color depth for surface");
+    }
 
-    if (!pgSurface_Lock((pgSurfaceObject *)self))
+    if (!pgSurface_Lock((pgSurfaceObject *)self)) {
+        if (PyErr_Occurred()) {
+            PyErr_Print();
+            PyErr_Clear();
+        }
+        PyErr_SetString(pgExc_SDLError, "Failed to lock surface");
         return NULL;
+    }
 
     pixels = (Uint8 *)surf->pixels;
 
@@ -769,8 +780,14 @@ surf_get_at(PyObject *self, PyObject *position)
                        rgba + 3);
             break;
     }
-    if (!pgSurface_Unlock((pgSurfaceObject *)self))
+    if (!pgSurface_Unlock((pgSurfaceObject *)self)) {
+        if (PyErr_Occurred()) {
+            PyErr_Print();
+            PyErr_Clear();
+        }
+        PyErr_SetString(pgExc_SDLError, "Failed to unlock surface in get_at");
         return NULL;
+    }
 
     return pgColor_New(rgba);
 }
@@ -805,8 +822,9 @@ surf_set_at(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
     }
     int bpp = PG_FORMAT_BytesPerPixel(format);
 
-    if (bpp < 1 || bpp > 4)
+    if (bpp < 1 || bpp > 4) {
         return RAISE(PyExc_RuntimeError, "invalid color depth for surface");
+    }
 
     SDL_Rect clip_rect;
     if (!PG_GetSurfaceClipRect(surf, &clip_rect)) {
@@ -816,15 +834,23 @@ surf_set_at(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
     if (x < clip_rect.x || x >= clip_rect.x + clip_rect.w || y < clip_rect.y ||
         y >= clip_rect.y + clip_rect.h) {
         /* out of clip area */
+
         Py_RETURN_NONE;
     }
 
     if (!pg_MappedColorFromObj(rgba_obj, surf, &color, PG_COLOR_HANDLE_ALL)) {
         return NULL;
     }
 
-    if (!pgSurface_Lock((pgSurfaceObject *)self))
+    if (!pgSurface_Lock((pgSurfaceObject *)self)) {
+        if (PyErr_Occurred()) {
+            PyErr_Print();
+            PyErr_Clear();
+        }
+        PyErr_SetString(pgExc_SDLError, "Failed to lock surface");
+
         return NULL;
+    }
     pixels = (Uint8 *)surf->pixels;
 
     switch (bpp) {
@@ -859,8 +885,15 @@ surf_set_at(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
             break;
     }
 
-    if (!pgSurface_Unlock((pgSurfaceObject *)self))
+    if (!pgSurface_Unlock((pgSurfaceObject *)self)) {
+        if (PyErr_Occurred()) {
+            PyErr_Print();
+            PyErr_Clear();
+        }
+        PyErr_SetString(pgExc_SDLError, "Failed to unlock surface in set_at");
+
         return NULL;
+    }
 
     Py_RETURN_NONE;
 }
@@ -4223,6 +4256,9 @@ MODINIT_DEFINE(surface)
     if (module == NULL) {
         return NULL;
     }
+
+    DISABLE_GIL_SINGLE_INITIALIZATION(module, _module.m_name)
+
     if (pg_warn_simd_at_runtime_but_uncompiled() < 0) {
         Py_DECREF(module);
         return NULL;

src_c/surflock.c

@@ -76,22 +76,30 @@ pgSurface_LockBy(pgSurfaceObject *surfobj, PyObject *lockobj)
     PyObject *ref;
     pgSurfaceObject *surf = (pgSurfaceObject *)surfobj;
 
+    // PyThreadState* ts = PyGILState_GetThisThreadState();
+    // printf("Locking surface in thread %llu\n", PyThreadState_GetID(ts));
+    LOCK_pgSurfaceObject(surfobj);
+
     if (surf->locklist == NULL) {
         surf->locklist = PyList_New(0);
         if (surf->locklist == NULL) {
+            UNLOCK_pgSurfaceObject(surfobj);
             return 0;
         }
     }
     ref = PyWeakref_NewRef(lockobj, NULL);
     if (ref == NULL) {
+        UNLOCK_pgSurfaceObject(surfobj);
         return 0;
     }
     if (ref == Py_None) {
         Py_DECREF(ref);
+        UNLOCK_pgSurfaceObject(surfobj);
         return 0;
     }
     if (0 != PyList_Append(surf->locklist, ref)) {
         Py_DECREF(ref);
+        UNLOCK_pgSurfaceObject(surfobj);
         return 0; /* Exception already set. */
     }
     Py_DECREF(ref);
@@ -106,8 +114,10 @@ pgSurface_LockBy(pgSurfaceObject *surfobj, PyObject *lockobj)
 #endif
     {
         PyErr_SetString(PyExc_RuntimeError, "error locking surface");
+        UNLOCK_pgSurfaceObject(surfobj);
         return 0;
     }
+
     return 1;
 }
 
@@ -167,6 +177,7 @@ pgSurface_UnlockBy(pgSurfaceObject *surfobj, PyObject *lockobj)
     }
 
     if (!found) {
+        UNLOCK_pgSurfaceObject(surfobj);
         return noerror;
     }
 
@@ -181,6 +192,9 @@ pgSurface_UnlockBy(pgSurfaceObject *surfobj, PyObject *lockobj)
         found--;
     }
 
+    // PyThreadState* ts = PyGILState_GetThisThreadState();
+    // printf("Unlocking surface in thread %llu\n", PyThreadState_GetID(ts));
+    UNLOCK_pgSurfaceObject(surfobj);
     return noerror;
 }