121 lines
5.8 KiB
Cython
121 lines
5.8 KiB
Cython
cdef extern from "Python.h":
|
|
|
|
#####################################################################
|
|
# 9.2 Memory Interface
|
|
#####################################################################
|
|
# You are definitely *supposed* to use these: "In most situations,
|
|
# however, it is recommended to allocate memory from the Python
|
|
# heap specifically because the latter is under control of the
|
|
# Python memory manager. For example, this is required when the
|
|
# interpreter is extended with new object types written in
|
|
# C. Another reason for using the Python heap is the desire to
|
|
# inform the Python memory manager about the memory needs of the
|
|
# extension module. Even when the requested memory is used
|
|
# exclusively for internal, highly-specific purposes, delegating
|
|
# all memory requests to the Python memory manager causes the
|
|
# interpreter to have a more accurate image of its memory
|
|
# footprint as a whole. Consequently, under certain circumstances,
|
|
# the Python memory manager may or may not trigger appropriate
|
|
# actions, like garbage collection, memory compaction or other
|
|
# preventive procedures. Note that by using the C library
|
|
# allocator as shown in the previous example, the allocated memory
|
|
# for the I/O buffer escapes completely the Python memory
|
|
# manager."
|
|
|
|
# The following function sets, modeled after the ANSI C standard,
|
|
# but specifying behavior when requesting zero bytes, are
|
|
# available for allocating and releasing memory from the Python
|
|
# heap:
|
|
|
|
void* PyMem_RawMalloc(size_t n) nogil
|
|
void* PyMem_Malloc(size_t n)
|
|
# Allocates n bytes and returns a pointer of type void* to the
|
|
# allocated memory, or NULL if the request fails. Requesting zero
|
|
# bytes returns a distinct non-NULL pointer if possible, as if
|
|
# PyMem_Malloc(1) had been called instead. The memory will not
|
|
# have been initialized in any way.
|
|
|
|
void* PyMem_RawCalloc(size_t nelem, size_t elsize) nogil
|
|
void* PyMem_Calloc(size_t nelem, size_t elsize)
|
|
# Allocates nelem elements each whose size in bytes is elsize and
|
|
# returns a pointer of type void* to the allocated memory, or NULL if
|
|
# the request fails. The memory is initialized to zeros. Requesting
|
|
# zero elements or elements of size zero bytes returns a distinct
|
|
# non-NULL pointer if possible, as if PyMem_Calloc(1, 1) had been
|
|
# called instead.
|
|
|
|
void* PyMem_RawRealloc(void *p, size_t n) nogil
|
|
void* PyMem_Realloc(void *p, size_t n)
|
|
# Resizes the memory block pointed to by p to n bytes. The
|
|
# contents will be unchanged to the minimum of the old and the new
|
|
# sizes. If p is NULL, the call is equivalent to PyMem_Malloc(n);
|
|
# else if n is equal to zero, the memory block is resized but is
|
|
# not freed, and the returned pointer is non-NULL. Unless p is
|
|
# NULL, it must have been returned by a previous call to
|
|
# PyMem_Malloc(), PyMem_Realloc(), or PyMem_Calloc().
|
|
|
|
void PyMem_RawFree(void *p) nogil
|
|
void PyMem_Free(void *p)
|
|
# Frees the memory block pointed to by p, which must have been
|
|
# returned by a previous call to PyMem_Malloc(), PyMem_Realloc(), or
|
|
# PyMem_Calloc(). Otherwise, or if PyMem_Free(p) has been called
|
|
# before, undefined behavior occurs. If p is NULL, no operation is
|
|
# performed.
|
|
|
|
# The following type-oriented macros are provided for
|
|
# convenience. Note that TYPE refers to any C type.
|
|
|
|
# TYPE* PyMem_New(TYPE, size_t n)
|
|
# Same as PyMem_Malloc(), but allocates (n * sizeof(TYPE)) bytes
|
|
# of memory. Returns a pointer cast to TYPE*. The memory will not
|
|
# have been initialized in any way.
|
|
|
|
# TYPE* PyMem_Resize(void *p, TYPE, size_t n)
|
|
# Same as PyMem_Realloc(), but the memory block is resized to (n *
|
|
# sizeof(TYPE)) bytes. Returns a pointer cast to TYPE*.
|
|
|
|
void PyMem_Del(void *p)
|
|
# Same as PyMem_Free().
|
|
|
|
# In addition, the following macro sets are provided for calling
|
|
# the Python memory allocator directly, without involving the C
|
|
# API functions listed above. However, note that their use does
|
|
# not preserve binary compatibility across Python versions and is
|
|
# therefore deprecated in extension modules.
|
|
|
|
# PyMem_MALLOC(), PyMem_REALLOC(), PyMem_FREE().
|
|
# PyMem_NEW(), PyMem_RESIZE(), PyMem_DEL().
|
|
|
|
|
|
#####################################################################
|
|
# Raw object memory interface
|
|
#####################################################################
|
|
|
|
# Functions to call the same malloc/realloc/free as used by Python's
|
|
# object allocator. If WITH_PYMALLOC is enabled, these may differ from
|
|
# the platform malloc/realloc/free. The Python object allocator is
|
|
# designed for fast, cache-conscious allocation of many "small" objects,
|
|
# and with low hidden memory overhead.
|
|
#
|
|
# PyObject_Malloc(0) returns a unique non-NULL pointer if possible.
|
|
#
|
|
# PyObject_Realloc(NULL, n) acts like PyObject_Malloc(n).
|
|
# PyObject_Realloc(p != NULL, 0) does not return NULL, or free the memory
|
|
# at p.
|
|
#
|
|
# Returned pointers must be checked for NULL explicitly; no action is
|
|
# performed on failure other than to return NULL (no warning it printed, no
|
|
# exception is set, etc).
|
|
#
|
|
# For allocating objects, use PyObject_{New, NewVar} instead whenever
|
|
# possible. The PyObject_{Malloc, Realloc, Free} family is exposed
|
|
# so that you can exploit Python's small-block allocator for non-object
|
|
# uses. If you must use these routines to allocate object memory, make sure
|
|
# the object gets initialized via PyObject_{Init, InitVar} after obtaining
|
|
# the raw memory.
|
|
|
|
void* PyObject_Malloc(size_t size)
|
|
void* PyObject_Calloc(size_t nelem, size_t elsize)
|
|
void* PyObject_Realloc(void *ptr, size_t new_size)
|
|
void PyObject_Free(void *ptr)
|