cpython/Modules/_testinternalcapi/parts.h

#ifndef Py_TESTINTERNALCAPI_PARTS_H
#define Py_TESTINTERNALCAPI_PARTS_H

// Always enable assertions
#undef NDEBUG

#ifndef Py_BUILD_CORE_BUILTIN
#  define Py_BUILD_CORE_MODULE 1
#endif

#include "Python.h"

int _PyTestInternalCapi_Init_Lock(PyObject *module);
int _PyTestInternalCapi_Init_PyTime(PyObject *module);
int _PyTestInternalCapi_Init_Set(PyObject *module);
int _PyTestInternalCapi_Init_CriticalSection(PyObject *module);

#endif // Py_TESTINTERNALCAPI_PARTS_H
gh-108777: Split _PyTime tests from _testinternalcapi.c (gh-108787) 2023-09-01 21:46:36 -03:00			`#ifndef Py_TESTINTERNALCAPI_PARTS_H`
			`#define Py_TESTINTERNALCAPI_PARTS_H`

			`// Always enable assertions`
			`#undef NDEBUG`

			`#ifndef Py_BUILD_CORE_BUILTIN`
			`# define Py_BUILD_CORE_MODULE 1`
			`#endif`

			`#include "Python.h"`

gh-108724: Add PyMutex and _PyParkingLot APIs (gh-109344) PyMutex is a one byte lock with fast, inlineable lock and unlock functions for the common uncontended case. The design is based on WebKit's WTF::Lock. PyMutex is built using the _PyParkingLot APIs, which provides a cross-platform futex-like API (based on WebKit's WTF::ParkingLot). This internal API will be used for building other synchronization primitives used to implement PEP 703, such as one-time initialization and events. This also includes tests and a mini benchmark in Tools/lockbench/lockbench.py to compare with the existing PyThread_type_lock. Uncontended acquisition + release: * Linux (x86-64): PyMutex: 11 ns, PyThread_type_lock: 44 ns * macOS (arm64): PyMutex: 13 ns, PyThread_type_lock: 18 ns * Windows (x86-64): PyMutex: 13 ns, PyThread_type_lock: 38 ns PR Overview: The primary purpose of this PR is to implement PyMutex, but there are a number of support pieces (described below). * PyMutex: A 1-byte lock that doesn't require memory allocation to initialize and is generally faster than the existing PyThread_type_lock. The API is internal only for now. * _PyParking_Lot: A futex-like API based on the API of the same name in WebKit. Used to implement PyMutex. * _PyRawMutex: A word sized lock used to implement _PyParking_Lot. * PyEvent: A one time event. This was used a bunch in the "nogil" fork and is useful for testing the PyMutex implementation, so I've included it as part of the PR. * pycore_llist.h: Defines common operations on doubly-linked list. Not strictly necessary (could do the list operations manually), but they come up frequently in the "nogil" fork. ( Similar to https://man.freebsd.org/cgi/man.cgi?queue) --------- Co-authored-by: Eric Snow <ericsnowcurrently@gmail.com> 2023-09-19 12:54:29 -03:00			`int _PyTestInternalCapi_Init_Lock(PyObject *module);`
gh-108777: Split _PyTime tests from _testinternalcapi.c (gh-108787) 2023-09-01 21:46:36 -03:00			`int _PyTestInternalCapi_Init_PyTime(PyObject *module);`
gh-110525: Add tests for internal `set` CAPI (GH-110630) 2023-10-10 13:00:05 -03:00			`int _PyTestInternalCapi_Init_Set(PyObject *module);`
gh-111569: Implement Python critical section API (gh-111571) Critical sections are helpers to replace the global interpreter lock with finer grained locking. They provide similar guarantees to the GIL and avoid the deadlock risk that plain locking involves. Critical sections are implicitly ended whenever the GIL would be released. They are resumed when the GIL would be acquired. Nested critical sections behave as if the sections were interleaved. 2023-11-08 18:39:29 -04:00			`int _PyTestInternalCapi_Init_CriticalSection(PyObject *module);`
gh-108777: Split _PyTime tests from _testinternalcapi.c (gh-108787) 2023-09-01 21:46:36 -03:00
			`#endif // Py_TESTINTERNALCAPI_PARTS_H`