PyCyBase 0.1.8.post4__cp313-cp313-win_amd64.whl

cbase/allocator_protocol/c_nt_shm_allocator.pxd

@@ -0,0 +1,102 @@
+
+cdef extern from "cbase/allocator_protocol/c_nt_shm_allocator.h":
+    const size_t AP_SHM_AUTOPAGE_CAPACITY
+    const size_t AP_SHM_AUTOPAGE_CAPACITY_MAX
+    const size_t AP_SHM_AUTOPAGE_ALIGNMENT
+    const char* AP_SHM_ALLOCATOR_PREFIX
+    const size_t AP_SHM_NAME_LEN
+    const size_t AP_SHM_PREFIX_MAX
+    const size_t AP_SHM_ALLOCATOR_DEFAULT_REGION_SIZE
+    const size_t c_nt_shm_page_overhead
+    const size_t c_nt_shm_block_overhead
+
+    ctypedef unsigned long DWORD
+
+    ctypedef struct pthread_mutex_t:
+        pass
+
+    ctypedef struct nt_shm_page:
+        size_t capacity
+        size_t occupied
+        size_t offset
+        nt_shm_allocator* allocator
+        nt_shm_memory_block* allocated
+        char shm_name[AP_SHM_NAME_LEN]
+        char prev_name[AP_SHM_NAME_LEN]
+
+    ctypedef struct nt_shm_page_ctx:
+        nt_shm_page* shm_page
+        void* handle
+        char* buffer
+        nt_shm_page_ctx* prev
+
+    ctypedef struct nt_shm_memory_block:
+        size_t capacity
+        size_t size
+        nt_shm_memory_block* next_free
+        nt_shm_memory_block* next_allocated
+        nt_shm_page* parent_page
+        char buffer[]
+
+    ctypedef struct nt_shm_allocator:
+        char shm_name[AP_SHM_NAME_LEN]
+        size_t pid
+        char lock_name[AP_SHM_NAME_LEN]
+        size_t mapped_size
+        char active_page[AP_SHM_NAME_LEN]
+        size_t mapped_pages
+        nt_shm_memory_block* free_list
+        size_t autopage_capacity
+        size_t autopage_capacity_max
+        size_t autopage_alignment
+        char shm_prefix[AP_SHM_PREFIX_MAX]
+        pthread_mutex_t lock
+
+    ctypedef struct nt_shm_allocator_ctx:
+        nt_shm_allocator* shm_allocator
+        void* shm_handle
+        void* lock_handle
+        nt_shm_page_ctx* active_page
+
+    int pthread_mutex_init(pthread_mutex_t* mutex, void* attr)
+    int pthread_mutex_lock(pthread_mutex_t* mutex)
+    int pthread_mutex_unlock(pthread_mutex_t* mutex)
+    int pthread_mutex_destroy(pthread_mutex_t* mutex)
+
+    size_t c_nt_shm_page_roundup(nt_shm_allocator* allocator, size_t size)
+    size_t c_nt_shm_block_roundup(size_t size)
+    void c_nt_shm_allocator_name(const char* shm_prefix, char* out)
+    void c_nt_shm_page_name(nt_shm_allocator* allocator, char* out)
+    void c_nt_shm_mutex_name(const char* shm_prefix, char* out)
+    int c_nt_shm_scan(const char* prefix, const char* suffix, char* out, size_t out_len)
+    nt_shm_page_ctx* c_nt_shm_page_new(nt_shm_allocator* allocator, size_t page_capacity)
+    int c_nt_shm_page_map(nt_shm_allocator* allocator, nt_shm_page_ctx* page_ctx)
+    void c_nt_shm_page_reclaim(nt_shm_allocator* allocator, nt_shm_page_ctx* page_ctx)
+
+    nt_shm_page_ctx* c_nt_shm_allocator_extend(nt_shm_allocator_ctx* ctx, size_t capacity, pthread_mutex_t* lock)
+    nt_shm_allocator_ctx* c_nt_shm_allocator_new(size_t region_size, const char* shm_prefix)
+    void c_nt_shm_allocator_free(nt_shm_allocator_ctx* ctx)
+    void* c_nt_shm_calloc(nt_shm_allocator_ctx* ctx, size_t size, pthread_mutex_t* lock)
+    void* c_nt_shm_request(nt_shm_allocator_ctx* ctx, size_t size, int scan_all_pages, pthread_mutex_t* lock)
+    void c_nt_shm_free(void* ptr, pthread_mutex_t* lock)
+    void c_nt_shm_reclaim(nt_shm_allocator_ctx* ctx, pthread_mutex_t* lock)
+    int c_nt_shm_scan_allocator(const char* shm_prefix, char* out)
+    int c_nt_shm_scan_page(const char* shm_prefix, char* out)
+    DWORD c_nt_shm_pid(const char* shm_name)
+    nt_shm_allocator* c_nt_shm_allocator_dangling(const char* shm_prefix, char* shm_name)
+    void c_nt_shm_clear_dangling(const char* shm_prefix)
+
+
+cdef class NtSharedMemoryAllocator:
+    cdef nt_shm_allocator_ctx* ctx
+    cdef readonly bint owner
+
+    cdef inline void* c_calloc(self, size_t size, pthread_mutex_t* lock=?)
+    cdef inline void* c_request(self, size_t size, int scan_all_pages=?, pthread_mutex_t* lock=?)
+    cdef inline void c_free(self, void* ptr, pthread_mutex_t* lock=?)
+
+    cpdef object calloc(self, size_t size, bint with_lock=?)
+    cpdef object request(self, size_t size, bint scan_all_pages=?, bint with_lock=?)
+    cpdef void free(self, object buffer, bint with_lock=?)
+    cpdef void reclaim(self, bint with_lock=?)
+    cpdef object extend(self, size_t capacity=?, bint with_lock=?)

cbase/allocator_protocol/c_nt_shm_allocator.pyx

@@ -0,0 +1,223 @@
+"""NT-native shared memory allocator (Windows-only).
+
+Provides NtSharedMemoryAllocator — a crude, test-focused wrapper around
+c_nt_shm_allocator.h.  Uses Windows kernel objects (CreateFileMappingW,
+MapViewOfFile, named mutexes) instead of POSIX SHM.
+"""
+from cpython.unicode cimport PyUnicode_FromString, PyUnicode_AsUTF8
+from libc.errno cimport errno
+
+
+cdef class NtSharedMemoryAllocator:
+    """Windows-native shared memory allocator.
+
+    Mirrors the POSIX SharedMemoryAllocator API but uses NT kernel objects:
+    - CreateFileMappingW for named shared memory
+    - MapViewOfFile / UnmapViewOfFile for mapping
+    - CreateMutexW for inter-process synchronization
+    """
+
+    def __init__(
+        self,
+        size_t region_size=AP_SHM_ALLOCATOR_DEFAULT_REGION_SIZE,
+        str shm_prefix=None
+    ):
+        if not region_size:
+            return
+        cdef const char* prefix = PyUnicode_AsUTF8(shm_prefix) if shm_prefix else NULL
+        self.ctx = c_nt_shm_allocator_new(region_size, prefix)
+        if not self.ctx:
+            raise OSError(errno, "Initialize NT SHM allocator failed")
+        self.owner = True
+
+    def __dealloc__(self):
+        if not self.owner:
+            return
+        if self.ctx:
+            c_nt_shm_allocator_free(self.ctx)
+
+    cdef inline void* c_calloc(self, size_t size, pthread_mutex_t* lock=NULL):
+        if not self.ctx:
+            raise RuntimeError(f"Uninitialized <{self.__class__.__name__}>")
+        return c_nt_shm_calloc(self.ctx, size, lock)
+
+    cdef inline void* c_request(self, size_t size, int scan_all_pages=1, pthread_mutex_t* lock=NULL):
+        if not self.ctx:
+            raise RuntimeError(f"Uninitialized <{self.__class__.__name__}>")
+        return c_nt_shm_request(self.ctx, size, scan_all_pages, lock)
+
+    cdef inline void c_free(self, void* ptr, pthread_mutex_t* lock=NULL):
+        if not self.ctx:
+            raise RuntimeError(f"Uninitialized <{self.__class__.__name__}>")
+        c_nt_shm_free(ptr, lock)
+
+    def __repr__(self):
+        if self.ctx and self.ctx.shm_allocator:
+            return (
+                f"<{self.__class__.__name__}"
+                f"(name={self.name}, pid={self.pid})>"
+            )
+        return f"<{self.__class__.__name__}(uninitialized)>"
+
+    # -- Public Python API ---------------------------------------------------
+
+    cpdef object calloc(self, size_t size, bint with_lock=True):
+        """Allocate zeroed memory.  Returns a read-write memoryview of ``size`` bytes."""
+        if not self.ctx:
+            raise RuntimeError(f"Uninitialized <{self.__class__.__name__}>")
+        cdef pthread_mutex_t* lock = &self.ctx.shm_allocator.lock if with_lock else NULL
+        cdef void* p = c_nt_shm_calloc(self.ctx, size, lock)
+        if not p:
+            raise OSError(
+                errno,
+                f"<{self.__class__.__name__}> failed to calloc {size} bytes",
+            )
+        cdef unsigned char[:] view = <unsigned char[:size]>p
+        return view
+
+    cpdef object request(self, size_t size, bint scan_all_pages=True, bint with_lock=True):
+        """Allocate memory (reuses freed blocks).  Returns a read-write memoryview."""
+        if not self.ctx:
+            raise RuntimeError(f"Uninitialized <{self.__class__.__name__}>")
+        cdef pthread_mutex_t* lock = &self.ctx.shm_allocator.lock if with_lock else NULL
+        cdef void* p = c_nt_shm_request(self.ctx, size, scan_all_pages, lock)
+        if not p:
+            raise OSError(
+                errno,
+                f"<{self.__class__.__name__}> failed to request {size} bytes",
+            )
+        cdef unsigned char[:] view = <unsigned char[:size]>p
+        return view
+
+    cpdef void free(self, object buffer, bint with_lock=True):
+        """Return a previously allocated buffer to the free list."""
+        if not self.ctx:
+            raise RuntimeError(f"Uninitialized <{self.__class__.__name__}>")
+        if buffer is None:
+            return
+        cdef const unsigned char[::1] view = buffer
+        cdef void* ptr = <void*>&view[0]
+        cdef pthread_mutex_t* lock = &self.ctx.shm_allocator.lock if with_lock else NULL
+        if ptr:
+            c_nt_shm_free(ptr, lock)
+
+    cpdef void reclaim(self, bint with_lock=True):
+        """Run best-effort reclaim of freed blocks across all pages."""
+        if not self.ctx:
+            raise RuntimeError(f"Uninitialized <{self.__class__.__name__}>")
+        cdef pthread_mutex_t* lock = &self.ctx.shm_allocator.lock if with_lock else NULL
+        c_nt_shm_reclaim(self.ctx, lock)
+
+    cpdef object extend(self, size_t capacity=0, bint with_lock=True):
+        """Manually extend the allocator with a new page."""
+        if not self.ctx:
+            raise RuntimeError(f"Uninitialized <{self.__class__.__name__}>")
+        cdef pthread_mutex_t* lock = &self.ctx.shm_allocator.lock if with_lock else NULL
+        cdef nt_shm_page_ctx* page = c_nt_shm_allocator_extend(
+            self.ctx, capacity, lock,
+        )
+        if not page:
+            raise OSError(
+                errno,
+                f"<{self.__class__.__name__}> failed to extend new page",
+            )
+        return {
+            "capacity": <size_t>page.shm_page.capacity,
+            "occupied": <size_t>page.shm_page.occupied,
+            "name": PyUnicode_FromString(page.shm_page.shm_name),
+        }
+
+    # -- Scanning / housekeeping ---------------------------------------------
+
+    def dangling(self, str shm_prefix=None):
+        """List allocator SHM objects whose creating process is dead."""
+        cdef char out[AP_SHM_NAME_LEN]
+        cdef const char* prefix = (
+            PyUnicode_AsUTF8(shm_prefix) if shm_prefix else NULL
+        )
+        cdef nt_shm_allocator* found = c_nt_shm_allocator_dangling(prefix, out)
+        if found:
+            return [PyUnicode_FromString(out)]
+        return []
+
+    def cleanup_dangling(self, str shm_prefix=None):
+        """Unlink all dangling allocator/page SHM objects."""
+        c_nt_shm_clear_dangling(
+            PyUnicode_AsUTF8(shm_prefix) if shm_prefix else NULL
+        )
+
+    # -- Properties ----------------------------------------------------------
+
+    property name:
+        def __get__(self) -> str:
+            if not self.ctx or not self.ctx.shm_allocator:
+                return None
+            return PyUnicode_FromString(self.ctx.shm_allocator.shm_name)
+
+    property pid:
+        def __get__(self):
+            if not self.ctx or not self.ctx.shm_allocator:
+                return -1
+            return <DWORD>self.ctx.shm_allocator.pid
+
+    property mapped_size:
+        def __get__(self):
+            if not self.ctx or not self.ctx.shm_allocator:
+                return -1
+            return <size_t>self.ctx.shm_allocator.mapped_size
+
+    property mapped_pages:
+        def __get__(self):
+            if not self.ctx or not self.ctx.shm_allocator:
+                return -1
+            return <size_t>self.ctx.shm_allocator.mapped_pages
+
+    property autopage_capacity:
+        def __get__(self):
+            if not self.ctx or not self.ctx.shm_allocator:
+                raise RuntimeError(f"Uninitialized <{self.__class__.__name__}>")
+            return <size_t>self.ctx.shm_allocator.autopage_capacity
+
+        def __set__(self, size_t value):
+            if not self.ctx or not self.ctx.shm_allocator:
+                raise RuntimeError(f"Uninitialized <{self.__class__.__name__}>")
+            self.ctx.shm_allocator.autopage_capacity = value
+
+    property autopage_capacity_max:
+        def __get__(self):
+            if not self.ctx or not self.ctx.shm_allocator:
+                raise RuntimeError(f"Uninitialized <{self.__class__.__name__}>")
+            return <size_t>self.ctx.shm_allocator.autopage_capacity_max
+
+        def __set__(self, size_t value):
+            if not self.ctx or not self.ctx.shm_allocator:
+                raise RuntimeError(f"Uninitialized <{self.__class__.__name__}>")
+            self.ctx.shm_allocator.autopage_capacity_max = value
+
+    property autopage_alignment:
+        def __get__(self):
+            if not self.ctx or not self.ctx.shm_allocator:
+                raise RuntimeError(f"Uninitialized <{self.__class__.__name__}>")
+            return <size_t>self.ctx.shm_allocator.autopage_alignment
+
+        def __set__(self, size_t value):
+            if not self.ctx or not self.ctx.shm_allocator:
+                raise RuntimeError(f"Uninitialized <{self.__class__.__name__}>")
+            self.ctx.shm_allocator.autopage_alignment = value
+
+    property shm_prefix:
+        def __get__(self) -> str:
+            if not self.ctx or not self.ctx.shm_allocator:
+                return None
+            return PyUnicode_FromString(self.ctx.shm_allocator.shm_prefix)
+
+
+# -- Module-level constant exports -------------------------------------------
+
+globals()['AP_SHM_AUTOPAGE_CAPACITY'] = AP_SHM_AUTOPAGE_CAPACITY
+globals()['AP_SHM_AUTOPAGE_CAPACITY_MAX'] = AP_SHM_AUTOPAGE_CAPACITY_MAX
+globals()['AP_SHM_AUTOPAGE_ALIGNMENT'] = AP_SHM_AUTOPAGE_ALIGNMENT
+globals()['AP_SHM_ALLOCATOR_PREFIX'] = PyUnicode_FromString(AP_SHM_ALLOCATOR_PREFIX)
+globals()['AP_SHM_NAME_LEN'] = AP_SHM_NAME_LEN
+globals()['AP_SHM_PREFIX_MAX'] = AP_SHM_PREFIX_MAX
+globals()['AP_SHM_ALLOCATOR_DEFAULT_REGION_SIZE'] = AP_SHM_ALLOCATOR_DEFAULT_REGION_SIZE