我已经定义了一个ctypes类和一个相关的便利函数，如下所示：
class BNG_FFITuple(Structure):
_fields_ = [("a", c_uint32),
("b", c_uint32)]
class BNG_FFIArray(Structure):
_fields_ = [("data", c_void_p),
("len", c_size_t)]
# Allow implicit conversions from a sequence of 32-bit unsigned ints
@classmethod
def from_param(cls, seq):
return seq if isinstance(seq, cls) else cls(seq)
def __init__(self, seq, data_type = c_float):
array_type = data_type * len(seq)
raw_seq = array_type(*seq)
self.data = cast(raw_seq, c_void_p)
self.len = len(seq)
def bng_void_array_to_tuple_list(array, _func, _args):
res = cast(array.data, POINTER(BNG_FFITuple * array.len))[0]
return res
convert = lib.convert_to_bng
convert.argtypes = (BNG_FFIArray, BNG_FFIArray)
convert.restype = BNG_FFIArray
convert.errcheck = bng_void_array_to_tuple_list
drop_array = lib.drop_array
drop_array.argtypes = (POINTER(BNG_FFIArray),)
然后我定义了一个简单的便利函数：
def f(a, b):
return [(i.a, i.b) for i in iter(convert(a, b))]
大部分工作都很完美，但我有两个问题：
BNG_FFITuple而不是c_float来实例化c_uint32（因此字段为c_float），反之亦然，因此{{1} } BNG_FFIArray是data_type。不过，我不清楚如何做到这一点。c_uint32发送回我的dylib（参见POINTER(BNG_FFIArray) - 我已经在我的dylib中定义了一个函数），但是我不确定我应该在什么时候打电话给它。有没有办法以更整洁，更Pythonic的方式封装所有这些，这也更安全？我担心没有以强大的方式定义内存清理（在drop_array上？__exit__？）任何出错都会导致不一致的内存
答案 0 :(得分：3)
由于您可以控制生锈方面，最简单的方法是在调用之前从Python预先分配结果数组，并将所有内容传递到单个结构中。
下面的代码假设了这个修改，但是如果你不能这样做，还要指定你要进行重新分配的地方。
请注意，如果执行此类封装，则无需为库函数指定参数和结果处理等内容，因为您只需从单个位置调用实际函数，并始终使用完全相同的参数类型。
我不知道生锈（甚至我的C有点生锈），但下面的代码假设您重新定义生锈以匹配相当于这样的东西：
typedef struct FFIParams {
int32 source_ints;
int32 len;
void * a;
void * b;
void * result;
} FFIParams;
void convert_to_bng(FFIParams *p) {
}
这是Python。最后一点 - 由于参数结构的重用，这不是线程安全的。如果需要，这很容易修复。
from ctypes import c_uint32, c_float, c_size_t, c_void_p
from ctypes import Structure, POINTER, pointer, cast
from itertools import izip, islice
_test_standalone = __name__ == '__main__'
if _test_standalone:
class lib(object):
@staticmethod
def convert_to_bng(ptr_params):
params = ptr_params.contents
source_ints = params.source_ints
types = c_uint32, c_float
if not source_ints:
types = reversed(types)
length = params.len
src_type, dst_type = types
src_type = POINTER(length * src_type)
dst_type = POINTER(length * 2 * dst_type)
a = cast(params.a, src_type).contents
b = cast(params.b, src_type).contents
result = cast(params.result, dst_type).contents
# Assumes we are converting int to float or back...
func = float if source_ints else int
result[0::2] = map(func, a)
result[1::2] = map(func, b)
class _BNG_FFIParams(Structure):
_fields_ = [("source_ints", c_uint32),
("len", c_size_t),
("a", c_void_p),
("b", c_void_p),
("result", c_void_p)]
class _BNG_FFI(object):
int_type = c_uint32
float_type = c_float
_array_type = type(10 * int_type)
# This assumes we want the result to be opposite type.
# Maybe I misunderstood this -- easily fixable if so.
_result_type = {int_type: float_type, float_type: int_type}
def __init__(self):
my_params = _BNG_FFIParams()
self._params = my_params
self._pointer = POINTER(_BNG_FFIParams)(my_params)
self._converter = lib.convert_to_bng
def _getarray(self, seq, data_type):
# Optimization for pre-allocated correct array type
if type(type(seq)) == self._array_type and seq._type_ is data_type:
print("Optimized!")
return seq
return (data_type * len(seq))(*seq)
def __call__(self, a, b, data_type=float_type):
length = len(a)
if length != len(b):
raise ValueError("Input lengths must be same")
a, b = (self._getarray(x, data_type) for x in (a, b))
# This has the salutary side-effect of insuring we were
# passed a valid type
result = (length * 2 * self._result_type[data_type])()
params = self._params
params.source_ints = data_type is self.int_type
params.len = length
params.a = cast(pointer(a), c_void_p)
params.b = cast(pointer(b), c_void_p)
params.result = cast(pointer(result), c_void_p)
self._converter(self._pointer)
evens = islice(result, 0, None, 2)
odds = islice(result, 1, None, 2)
result = list(izip(evens, odds))
# If you have to have the converter allocate memory,
# deallocate it here...
return result
convert = _BNG_FFI()
if _test_standalone:
print(convert([1.0, 2.0, 3.0], [4.0, 5.0, 6.0], c_float))
print(convert([1, 2, 3], [4, 5, 6], c_uint32))
print(convert([1, 2, 3], (c_uint32 * 3)(4, 5, 6), c_uint32))
答案 1 :(得分：3)
以下是在被调用的DLL中分配返回数组的代码的修改版本。因为用纯Python测试会更难，而且因为我不知道生锈，所以我为实际测试构建了一个俗气的C库：
#include <stdlib.h>
#include <stdio.h>
typedef struct FFIParams {
int source_ints;
int len;
void * a;
void * b;
} FFIParams, *FFIParamsPtr;
typedef int * intptr;
typedef float * floatptr;
void * to_float(FFIParamsPtr p) {
floatptr result;
intptr a = p->a;
intptr b = p->b;
int i;
int size = sizeof(result[0]) * 2 * p->len;
result = malloc(size);
printf("Allocated %x bytes at %x\n", size, (unsigned int)result);
for (i = 0; i < p->len; i++) {
result[i*2+0] = (float)(a[i]);
result[i*2+1] = (float)(b[i]);
}
return result;
}
void * to_int(FFIParamsPtr p) {
intptr result;
floatptr a = p->a;
floatptr b = p->b;
int i;
int size = sizeof(result[0]) * 2 * p->len;
result = malloc(size);
printf("Allocated %x bytes at %x\n", size, (unsigned int)result);
for (i = 0; i < p->len; i++) {
result[i*2+0] = (int)(a[i]);
result[i*2+1] = (int)(b[i]);
}
return result;
}
void * convert_to_bng(FFIParamsPtr p) {
if (p->source_ints)
return to_float(p);
return to_int(p);
}
void free_bng_mem(void * data) {
printf("Deallocating memory at %x\n", (unsigned int)data);
free(data);
}
以下是调用它的Python代码：
from ctypes import c_uint32, c_float, c_size_t, c_void_p
from ctypes import Structure, POINTER, pointer, cast, cdll
from itertools import izip, islice
class _BNG_FFIParams(Structure):
_fields_ = [("source_ints", c_uint32),
("len", c_size_t),
("a", c_void_p),
("b", c_void_p)]
class _BNG_FFI(object):
int_type = c_uint32
float_type = c_float
_array_type = type(10 * int_type)
_lib = cdll.LoadLibrary('./testlib.so')
_converter = _lib.convert_to_bng
_converter.restype = c_void_p
_deallocate = _lib.free_bng_mem
_result_type = {int_type: float_type,
float_type: int_type}
def __init__(self):
my_params = _BNG_FFIParams()
self._params = my_params
self._pointer = POINTER(_BNG_FFIParams)(my_params)
def _getarray(self, seq, data_type):
# Optimization for pre-allocated correct array type
if type(type(seq)) == self._array_type and seq._type_ is data_type:
print("Optimized!")
return seq
return (data_type * len(seq))(*seq)
def __call__(self, a, b, data_type=float_type):
length = len(a)
if length != len(b):
raise ValueError("Input lengths must be same")
a, b = (self._getarray(x, data_type) for x in (a, b))
# This has the salutary side-effect of insuring we were
# passed a valid type
result_type = POINTER(length * 2 * self._result_type[data_type])
params = self._params
params.source_ints = data_type is self.int_type
params.len = length
params.a = cast(pointer(a), c_void_p)
params.b = cast(pointer(b), c_void_p)
resptr = self._converter(self._pointer)
result = cast(resptr, result_type).contents
evens = islice(result, 0, None, 2)
odds = islice(result, 1, None, 2)
result = list(izip(evens, odds))
self._deallocate(resptr)
return result
convert = _BNG_FFI()
if __name__ == '__main__':
print(convert([1.0, 2.0, 3.0], [4.0, 5.0, 6.0], c_float))
print(convert([1, 2, 3], [4, 5, 6], c_uint32))
print(convert([1, 2, 3], (c_uint32 * 3)(4, 5, 6), c_uint32))
这是我执行时的结果：
Allocated 18 bytes at 9088468
Deallocating memory at 9088468
[(1L, 4L), (2L, 5L), (3L, 6L)]
Allocated 18 bytes at 908a6b8
Deallocating memory at 908a6b8
[(1.0, 4.0), (2.0, 5.0), (3.0, 6.0)]
Optimized!
Allocated 18 bytes at 90e1ae0
Deallocating memory at 90e1ae0
[(1.0, 4.0), (2.0, 5.0), (3.0, 6.0)]
这恰好是一个32位的Ubuntu 14.04系统。我使用Python 2.7，并使用gcc --shared ffitest.c -o testlib.so -Wall