通过cython管理对calloc/free的呼叫
cymem的Python项目详细描述
cymem:cython内存助手
*****************
cymem为cython提供两个小内存管理助手。它们使
很容易将内存与python对象的生命周期绑定，这样当对象被垃圾收集时，内存就被释放了。图片：：https://img.shields.io/travis/explosion/cymem/master.svg？style=flat square&；logo=travis
：目标：https://travis ci.org/explosion/cymem
…图片：：https://img.shields.io/appveyor/ci/explosion/cymem/master.svg？style=flat square&；logo=appveyor
：目标：https://ci.appveyor.com/project/explosion/cymem
：alt:appveyor生成状态
。图片：：https://img.shields.io/pypi/v/cymem.svg？style=flat square
：目标：https://pypi.python.org/pypi/cymem
：alt:pypi版本
…图片：：https://img.shields.io/conda/vn/conda-forge/cymem.svg？style=flat square
：目标：https://anaconda.org/conda forge/cymem
：alt:conda版本
…图片：：https://img.shields.io/badge/wheels-%e2%9c%93-4c1.svg？longcache=true&；style=flat square&；logo=python&；logocolor=white
：target:https://github.com/explosion/wheelwright/releases
：alt:python wheels
概述
==
最有用的是"cymem.pool"，作为calloc函数的薄包装。代码：：python
cymem.cymem cimport pool
cdef pool mem=pool（）
data1=<；int*>；mem.alloc（10，sizeof（int））
data2=<；float*>；mem.alloc（12，sizeof（float））
"pool"对象在内部保存内存地址，并在垃圾回收
对象时释放它们。通常，您会将"pool"附加到一些cdef
类。这对于具有复杂初始化函数的深度嵌套结构特别方便。只需将"pool"对象传递到
初始值设定项中，就不必担心释放结构-
当"pool"过期时，对"pool.alloc"的所有调用都将自动释放。
https://pypi.python.org/pypi/pip>；``并要求'cython<；http://cython.org/>；`` ux.
…代码：：bash
pip install cymem
>示例用例：一个结构数组
========
我们需要快速访问，而python列表的性能还不够好。因此，我们需要一个C数组或C++ +BR/>向量，这意味着我们需要稀疏矩阵作为C级结构——它
不能是Python类。我们可以用cython很容易地写出这个：
…代码：：cython
"例如，如果不使用cymem
要使用结构数组，则在释放数据结构时，必须仔细遍历该结构。
"
大小*索引
双*值
cdef struct sparsematrix:
大小长度
sparserow*行
cdef类矩阵阵列：
cdef大小长度
cdef sparsematrix**矩阵
def cinit（self，列表py_矩阵：
self.length=0
self.matrices=null
def_u init_u（self，列表py_矩阵）：
self.length=len（py_矩阵）
self.matrices=<；sparsematrix**>；calloc（len（py_矩阵），sizeof（sparsematrix*）
对于i，枚举中的py_矩阵（py_矩阵）：
self.matrices[i]=稀疏矩阵初始（py_矩阵）
def_u dealloc_u（self）：
范围内的i（self.length）：
稀疏矩阵自由（self.matrices[i]）
自由（self.matrices）
cdef sparse matrix*稀疏矩阵初始化（列表py_m中庭）除空值外：
sm=<；sparsematrix*>；calloc（1，sizeof（sparsematrix））
sm.length=len（py_matrix）
sm.rows=<；sparserow*>；calloc（sm.length，sizeof（sparserow））
cdef size_i，j
cdef dict py row
cdef size_t idx
cdef双值
对于枚举（py_矩阵）中的i，py_行：
sm.rows[i].len=len（py_row）
sm.rows[i].index=<；size_t*>；calloc（sm.rows[i].length，sizeof（size_t））
sm.rows[i].values=<；double*>；calloc（sm.rows[i].length，尺寸of（双））
对于j，（idx，value）在枚举中（py_row.items（））：
sm.rows[i].index[j]=idx
sm.rows[i].values[j]=value
return sm
cdef void*sparse_matrix_free（sparsematrix*sm），除了i in的*：
cdef size_t i
范围（sm.length）：
free（sm.rows[i].index）
free（sm.rows[i].values）
free（sm.rows）
free（sm）
考虑到性能限制，我们将数据结构包装在python ref counted类中，级别尽可能低。这允许我们分配和释放特殊方法中的内存。
cymem完全阻止您编写这些deallocator。相反，你可以这样写：
…code：：cython
"cymem的示例。
内存分配隐藏在pool类后面，pool类记住它发出的
地址。当池对象被垃圾收集时，它的所有地址都被释放。
消除一类常见的错误。
"
来自cymem.cymem cimport pool
大小索引
双*值
cdef struct sparsermatrix:
大小长度
sparserow*行
CDEF类矩阵阵列：
CDEF大小长度
CDEF稀疏矩阵**矩阵
CDEF池内存
列表py_矩阵：
self.mem=none
self.length=0
self.matrix=null
def_u init_uu（self，列表py_u矩阵）：
self.mem=pool（）
self.leng=len（py_u矩阵）
self.matrix=<；sparse matrix**>；self.mem.alloc（self.length，sizeof（sparsematrix*））
对于枚举中的i，py_矩阵（py_矩阵）：
self.matrix[i]=稀疏矩阵初始（self.mem，py_矩阵）
cdef sparsematrix*稀疏矩阵初始（pool mem，列出py_矩阵）除空：
sm=<；sparsematrix*>；mem.alloc（1，sizeof（sparsematrix））
sm.length=len（py_矩阵）
sm.rows=<；sparserow*>；mem.alloc（sm.length，sizeof（sparserow））
cdef size_t i，j
cdef dict py_row
cdef size_t idx
cdef double value
对于枚举中的i，py_row（py_matrix）：
sm.rows[i].len=len（py_row）
sm.rows[i].index=<；size_t*>；mem.alloc（sm.rows[i].leng，sizeof（size_t））
sm.rows[i].values=<；double*>；mem.alloc（sm.rows[i].length，sizeof（double））
对于j，（idx，value）在枚举（py_row.items（））中：
sm.rows[i].index[j]=idx
sm.rows[i].values[j]=value
return sm
当
``matrixarray``对象被垃圾收集时，``pool``对象也将被垃圾
收集，这将触发对``pooL."解除锁定"。然后，"pool"释放其所有地址。这样就避免了在嵌套的数据结构中来回走动来释放它们，消除了一类常见的错误。
"池"的一部分。代码：：python
*****************
cymem为cython提供两个小内存管理助手。它们使
很容易将内存与python对象的生命周期绑定，这样当对象被垃圾收集时，内存就被释放了。图片：：https://img.shields.io/travis/explosion/cymem/master.svg？style=flat square&；logo=travis
：目标：https://travis ci.org/explosion/cymem
…图片：：https://img.shields.io/appveyor/ci/explosion/cymem/master.svg？style=flat square&；logo=appveyor
：目标：https://ci.appveyor.com/project/explosion/cymem
：alt:appveyor生成状态
。图片：：https://img.shields.io/pypi/v/cymem.svg？style=flat square
：目标：https://pypi.python.org/pypi/cymem
：alt:pypi版本
…图片：：https://img.shields.io/conda/vn/conda-forge/cymem.svg？style=flat square
：目标：https://anaconda.org/conda forge/cymem
：alt:conda版本
…图片：：https://img.shields.io/badge/wheels-%e2%9c%93-4c1.svg？longcache=true&；style=flat square&；logo=python&；logocolor=white
：target:https://github.com/explosion/wheelwright/releases
：alt:python wheels
概述
==
最有用的是"cymem.pool"，作为calloc函数的薄包装。代码：：python
cymem.cymem cimport pool
cdef pool mem=pool（）
data1=<；int*>；mem.alloc（10，sizeof（int））
data2=<；float*>；mem.alloc（12，sizeof（float））
"pool"对象在内部保存内存地址，并在垃圾回收
对象时释放它们。通常，您会将"pool"附加到一些cdef
类。这对于具有复杂初始化函数的深度嵌套结构特别方便。只需将"pool"对象传递到
初始值设定项中，就不必担心释放结构-
当"pool"过期时，对"pool.alloc"的所有调用都将自动释放。
https://pypi.python.org/pypi/pip>；``并要求'cython<；http://cython.org/>；`` ux.
…代码：：bash
pip install cymem
>示例用例：一个结构数组
========
我们需要快速访问，而python列表的性能还不够好。因此，我们需要一个C数组或C++ +BR/>向量，这意味着我们需要稀疏矩阵作为C级结构——它
不能是Python类。我们可以用cython很容易地写出这个：
…代码：：cython
"例如，如果不使用cymem
要使用结构数组，则在释放数据结构时，必须仔细遍历该结构。
"
大小*索引
双*值
cdef struct sparsematrix:
大小长度
sparserow*行
cdef类矩阵阵列：
cdef大小长度
cdef sparsematrix**矩阵
def cinit（self，列表py_矩阵：
self.length=0
self.matrices=null
def_u init_u（self，列表py_矩阵）：
self.length=len（py_矩阵）
self.matrices=<；sparsematrix**>；calloc（len（py_矩阵），sizeof（sparsematrix*）
对于i，枚举中的py_矩阵（py_矩阵）：
self.matrices[i]=稀疏矩阵初始（py_矩阵）
def_u dealloc_u（self）：
范围内的i（self.length）：
稀疏矩阵自由（self.matrices[i]）
自由（self.matrices）
cdef sparse matrix*稀疏矩阵初始化（列表py_m中庭）除空值外：
sm=<；sparsematrix*>；calloc（1，sizeof（sparsematrix））
sm.length=len（py_matrix）
sm.rows=<；sparserow*>；calloc（sm.length，sizeof（sparserow））
cdef size_i，j
cdef dict py row
cdef size_t idx
cdef双值
对于枚举（py_矩阵）中的i，py_行：
sm.rows[i].len=len（py_row）
sm.rows[i].index=<；size_t*>；calloc（sm.rows[i].length，sizeof（size_t））
sm.rows[i].values=<；double*>；calloc（sm.rows[i].length，尺寸of（双））
对于j，（idx，value）在枚举中（py_row.items（））：
sm.rows[i].index[j]=idx
sm.rows[i].values[j]=value
return sm
cdef void*sparse_matrix_free（sparsematrix*sm），除了i in的*：
cdef size_t i
范围（sm.length）：
free（sm.rows[i].index）
free（sm.rows[i].values）
free（sm.rows）
free（sm）
考虑到性能限制，我们将数据结构包装在python ref counted类中，级别尽可能低。这允许我们分配和释放特殊方法中的内存。
cymem完全阻止您编写这些deallocator。相反，你可以这样写：
…code：：cython
"cymem的示例。
内存分配隐藏在pool类后面，pool类记住它发出的
地址。当池对象被垃圾收集时，它的所有地址都被释放。
消除一类常见的错误。
"
来自cymem.cymem cimport pool
大小索引
双*值
cdef struct sparsermatrix:
大小长度
sparserow*行
CDEF类矩阵阵列：
CDEF大小长度
CDEF稀疏矩阵**矩阵
CDEF池内存
列表py_矩阵：
self.mem=none
self.length=0
self.matrix=null
def_u init_uu（self，列表py_u矩阵）：
self.mem=pool（）
self.leng=len（py_u矩阵）
self.matrix=<；sparse matrix**>；self.mem.alloc（self.length，sizeof（sparsematrix*））
对于枚举中的i，py_矩阵（py_矩阵）：
self.matrix[i]=稀疏矩阵初始（self.mem，py_矩阵）
cdef sparsematrix*稀疏矩阵初始（pool mem，列出py_矩阵）除空：
sm=<；sparsematrix*>；mem.alloc（1，sizeof（sparsematrix））
sm.length=len（py_矩阵）
sm.rows=<；sparserow*>；mem.alloc（sm.length，sizeof（sparserow））
cdef size_t i，j
cdef dict py_row
cdef size_t idx
cdef double value
对于枚举中的i，py_row（py_matrix）：
sm.rows[i].len=len（py_row）
sm.rows[i].index=<；size_t*>；mem.alloc（sm.rows[i].leng，sizeof（size_t））
sm.rows[i].values=<；double*>；mem.alloc（sm.rows[i].length，sizeof（double））
对于j，（idx，value）在枚举（py_row.items（））中：
sm.rows[i].index[j]=idx
sm.rows[i].values[j]=value
return sm
当
``matrixarray``对象被垃圾收集时，``pool``对象也将被垃圾
收集，这将触发对``pooL."解除锁定"。然后，"pool"释放其所有地址。这样就避免了在嵌套的数据结构中来回走动来释放它们，消除了一类常见的错误。
"池"的一部分。代码：：python
欢迎加入QQ群-->： 979659372
