Расширение Python - глотать, а не глотать или Cython - PullRequest
61 голосов
/ 19 января 2009

Я нашел узкое место в своем коде на python, поиграл с psycho и т. Д. Затем решил написать расширение c / c ++ для производительности.

С помощью swig вам почти не нужно заботиться об аргументах и ​​т. Д. Все отлично работает.

Теперь мой вопрос: swig создает довольно большой py-файл, который выполняет множество «проверок» и «PySwigObject» перед вызовом фактического кода .pyd или .so.

Есть ли у кого-нибудь из вас опыт, можно ли повысить производительность, если вы вручную напишите этот файл или позволите swig это сделать?

Ответы [ 10 ]

60 голосов
/ 19 января 2009

Вам следует рассмотреть Boost.Python, если вы не планируете создавать привязки для других языков также с помощью swig.

Если у вас много функций и классов для привязки, Py ++ - отличный инструмент, который автоматически генерирует необходимый код для создания привязок.

Pybindgen также может быть вариантом, но это новый проект и менее завершенный, чем Boost.Python.


Edit:

Может быть, мне нужно более подробно рассказать о плюсах и минусах.

  • Swig:

    pro: вы можете создавать привязки для многих языков сценариев.

    минусы: мне не нравится, как работает парсер. Я не знаю, удалось ли это сделать, но два года назад парсер C ++ был довольно ограниченным. Большую часть времени мне приходилось копировать / вставлять мои .h заголовки, добавлять некоторые символы % и давать дополнительные подсказки анализатору swig.

    Мне также приходилось время от времени иметь дело с C-API Python для (не очень) сложных преобразований типов.

    Я больше этим не пользуюсь.

  • Boost.Python:

    про: Это очень полная библиотека. Это позволяет вам делать практически все, что возможно с C-API, но на C ++. Мне никогда не приходилось писать код C-API с этой библиотекой. Я также никогда не сталкивался с ошибкой из-за библиотеки. Код для привязок либо работает как брелок, либо отказывается от компиляции.

    Вероятно, это одно из лучших доступных решений, если у вас уже есть библиотека C ++ для привязки. Но если у вас есть только небольшая функция C для перезаписи, я, вероятно, попробую с Cython.

    минусов: если у вас нет предварительно скомпилированной библиотеки Boost.Python, вы собираетесь использовать Bjam (что-то вроде замены). Я действительно ненавижу Bjam и его синтаксис.

    Библиотеки Python, созданные с помощью B.P, обычно страдают ожирением Для их компиляции также требуется лот времени.

  • Py ++ (снят с производства): это Boost.Python стало проще. Py ++ использует синтаксический анализатор C ++ для чтения вашего кода, а затем автоматически генерирует код Boost.Python. У вас также есть большая поддержка от его автора (нет, это не я ;-)).

    минусов: только проблемы из-за самого Boost.Python. Обновление: с 2014 года этот проект выглядит прекращенным.

  • Pybindgen:

    Генерирует код, связанный с C-API. Вы можете описать функции и классы в файле Python или позволить Pybindgen читать ваши заголовки и автоматически генерировать привязки (для этого используется pygccxml, библиотека python, написанная автором Py ++).

    минусов: это молодой проект с меньшей командой, чем Boost.Python. Есть все еще некоторые ограничения: вы не можете использовать множественное наследование для ваших классов C ++, Callbacks (не автоматически, хотя может быть написан специальный код обработки обратного вызова). Перевод исключений Python на C.

    Это определенно стоит посмотреть.

  • Новый: 2009/01/20 автор Py ++ анонсировал новый пакет для сопряжения кода C / C ++ с python. Он основан на типах. Я не пробовал это уже, но я буду! Примечание: этот проект выглядит прекращенным, как Py ++.

  • CFFI : Я не знал о существовании этого до недавнего времени, поэтому пока не могу высказать свое мнение. Похоже, вы можете определять функции C в строках Python и вызывать их напрямую из того же модуля Python.

  • Cython : этот метод я сейчас использую в своих проектах. В основном вы пишете код в специальных .pyx файлах. Эти файлы компилируются (переводятся) в код C, который, в свою очередь, компилируется в модули CPython. Код Cython может выглядеть как обычный Python (и на самом деле чистый Python - это допустимые файлы Python .pyx), но вы также можете получить больше информации, например, о типах переменных. Эта необязательная типизация позволяет Cython генерировать более быстрый C-код. Код в файлах Cython может вызывать как чистые функции Python, так и функции C и C ++ (а также методы C ++).

    Мне потребовалось некоторое время, чтобы подумать в Cython, что в одном и том же коде вызовите функцию C и C ++, смешайте переменные Python и C и так далее. Но это очень мощный язык с активным (в 2014 году) и дружелюбным сообществом.

27 голосов
/ 05 июля 2011

SWIG 2.0.4 представила новую опцию -builtin, которая улучшает производительность. Я провел несколько тестов, используя пример программы, которая выполняет много быстрых вызовов расширения C ++. Я построил расширение, используя boost.python, PyBindGen, SIP и SWIG с опцией -builtin и без нее. Вот результаты (в среднем за 100 прогонов):

SWIG with -builtin     2.67s
SIP                    2.70s
PyBindGen              2.74s
boost.python           3.07s
SWIG without -builtin  4.65s

SWIG раньше был медленным. С новой опцией -builtin, SWIG кажется самым быстрым.

26 голосов
/ 19 января 2009

Конечно, вы всегда будете иметь прирост производительности, делая это вручную, но прирост будет очень небольшим по сравнению с усилием, необходимым для этого. У меня нет никакой цифры, чтобы дать вам, но я не рекомендую это, потому что вам нужно будет поддерживать интерфейс вручную, и это не вариант, если ваш модуль большой!

Вы правильно выбрали язык сценариев, потому что хотели быстрой разработки. Таким образом, вы избежали синдрома ранней оптимизации, и теперь вы хотите оптимизировать узкие места, отлично! Но если вы сделаете интерфейс C / python вручную, вы наверняка попадете в синдром ранней оптимизации.

Если вам нужно что-то с меньшим количеством кода интерфейса, вы можете подумать о создании dll из вашего кода C и использовать эту библиотеку напрямую из python с cstruct .

Рассмотрим также Cython , если вы хотите использовать в своей программе только код Python.

16 голосов
/ 19 января 2009

Использование Cython довольно хорошо. Вы можете написать свое расширение C с Python-подобным синтаксисом и заставить его генерировать C-код. Котельная в комплекте. Поскольку у вас уже есть код на python, вам нужно сделать всего несколько изменений в своем коде узкого места, и код C будет сгенерирован из него.

Пример. hello.pyx

cdef int hello(int a, int b):
    return a + b

Генерирует 601 строк кода шаблона:

/* Generated by Cython 0.10.3 on Mon Jan 19 08:24:44 2009 */

#define PY_SSIZE_T_CLEAN
#include "Python.h"
#include "structmember.h"
#ifndef PY_LONG_LONG
  #define PY_LONG_LONG LONG_LONG
#endif
#ifndef DL_EXPORT
  #define DL_EXPORT(t) t
#endif
#if PY_VERSION_HEX < 0x02040000
  #define METH_COEXIST 0
#endif
#if PY_VERSION_HEX < 0x02050000
  typedef int Py_ssize_t;
  #define PY_SSIZE_T_MAX INT_MAX
  #define PY_SSIZE_T_MIN INT_MIN
  #define PyInt_FromSsize_t(z) PyInt_FromLong(z)
  #define PyInt_AsSsize_t(o)   PyInt_AsLong(o)
  #define PyNumber_Index(o)    PyNumber_Int(o)
  #define PyIndex_Check(o)     PyNumber_Check(o)
#endif
#if PY_VERSION_HEX < 0x02060000
  #define Py_REFCNT(ob) (((PyObject*)(ob))->ob_refcnt)
  #define Py_TYPE(ob)   (((PyObject*)(ob))->ob_type)
  #define Py_SIZE(ob)   (((PyVarObject*)(ob))->ob_size)
  #define PyVarObject_HEAD_INIT(type, size) \
          PyObject_HEAD_INIT(type) size,
  #define PyType_Modified(t)

  typedef struct {
       void *buf;
       PyObject *obj;
       Py_ssize_t len;
       Py_ssize_t itemsize;
       int readonly;
       int ndim;
       char *format;
       Py_ssize_t *shape;
       Py_ssize_t *strides;
       Py_ssize_t *suboffsets;
       void *internal;
  } Py_buffer;

  #define PyBUF_SIMPLE 0
  #define PyBUF_WRITABLE 0x0001
  #define PyBUF_LOCK 0x0002
  #define PyBUF_FORMAT 0x0004
  #define PyBUF_ND 0x0008
  #define PyBUF_STRIDES (0x0010 | PyBUF_ND)
  #define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES)
  #define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES)
  #define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES)
  #define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES)

#endif
#if PY_MAJOR_VERSION < 3
  #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
#else
  #define __Pyx_BUILTIN_MODULE_NAME "builtins"
#endif
#if PY_MAJOR_VERSION >= 3
  #define Py_TPFLAGS_CHECKTYPES 0
  #define Py_TPFLAGS_HAVE_INDEX 0
#endif
#if (PY_VERSION_HEX < 0x02060000) || (PY_MAJOR_VERSION >= 3)
  #define Py_TPFLAGS_HAVE_NEWBUFFER 0
#endif
#if PY_MAJOR_VERSION >= 3
  #define PyBaseString_Type            PyUnicode_Type
  #define PyString_Type                PyBytes_Type
  #define PyInt_Type                   PyLong_Type
  #define PyInt_Check(op)              PyLong_Check(op)
  #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
  #define PyInt_FromString             PyLong_FromString
  #define PyInt_FromUnicode            PyLong_FromUnicode
  #define PyInt_FromLong               PyLong_FromLong
  #define PyInt_FromSize_t             PyLong_FromSize_t
  #define PyInt_FromSsize_t            PyLong_FromSsize_t
  #define PyInt_AsLong                 PyLong_AsLong
  #define PyInt_AS_LONG                PyLong_AS_LONG
  #define PyInt_AsSsize_t              PyLong_AsSsize_t
  #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
  #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
#else
  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
  #define PyBytes_Type                 PyString_Type
#endif
#if PY_MAJOR_VERSION >= 3
  #define PyMethod_New(func, self, klass) PyInstanceMethod_New(func)
#endif
#if !defined(WIN32) && !defined(MS_WINDOWS)
  #ifndef __stdcall
    #define __stdcall
  #endif
  #ifndef __cdecl
    #define __cdecl
  #endif
#else
  #define _USE_MATH_DEFINES
#endif
#ifdef __cplusplus
#define __PYX_EXTERN_C extern "C"
#else
#define __PYX_EXTERN_C extern
#endif
#include <math.h>
#define __PYX_HAVE_API__helloworld

#ifdef __GNUC__
#define INLINE __inline__
#elif _WIN32
#define INLINE __inline
#else
#define INLINE 
#endif

typedef struct 
    {PyObject **p; char *s; long n; 
     char is_unicode; char intern; char is_identifier;} 
     __Pyx_StringTabEntry; /*proto*/

static int __pyx_skip_dispatch = 0;


/* Type Conversion Predeclarations */

#if PY_MAJOR_VERSION < 3
#define __Pyx_PyBytes_FromString PyString_FromString
#define __Pyx_PyBytes_AsString   PyString_AsString
#else
#define __Pyx_PyBytes_FromString PyBytes_FromString
#define __Pyx_PyBytes_AsString   PyBytes_AsString
#endif

#define __Pyx_PyBool_FromLong(b) ((b) ? (Py_INCREF(Py_True), Py_True) : (Py_INCREF(Py_False), Py_False))
static INLINE int __Pyx_PyObject_IsTrue(PyObject* x);
static INLINE PY_LONG_LONG __pyx_PyInt_AsLongLong(PyObject* x);
static INLINE unsigned PY_LONG_LONG __pyx_PyInt_AsUnsignedLongLong(PyObject* x);
static INLINE Py_ssize_t __pyx_PyIndex_AsSsize_t(PyObject* b);

#define __pyx_PyInt_AsLong(x) (PyInt_CheckExact(x) ? PyInt_AS_LONG(x) : PyInt_AsLong(x))
#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))

static INLINE unsigned char __pyx_PyInt_unsigned_char(PyObject* x);
static INLINE unsigned short __pyx_PyInt_unsigned_short(PyObject* x);
static INLINE char __pyx_PyInt_char(PyObject* x);
static INLINE short __pyx_PyInt_short(PyObject* x);
static INLINE int __pyx_PyInt_int(PyObject* x);
static INLINE long __pyx_PyInt_long(PyObject* x);
static INLINE signed char __pyx_PyInt_signed_char(PyObject* x);
static INLINE signed short __pyx_PyInt_signed_short(PyObject* x);
static INLINE signed int __pyx_PyInt_signed_int(PyObject* x);
static INLINE signed long __pyx_PyInt_signed_long(PyObject* x);
static INLINE long double __pyx_PyInt_long_double(PyObject* x);
#ifdef __GNUC__
/* Test for GCC > 2.95 */
#if __GNUC__ > 2 ||               (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)) 
#define likely(x)   __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)
#else /* __GNUC__ > 2 ... */
#define likely(x)   (x)
#define unlikely(x) (x)
#endif /* __GNUC__ > 2 ... */
#else /* __GNUC__ */
#define likely(x)   (x)
#define unlikely(x) (x)
#endif /* __GNUC__ */

static PyObject *__pyx_m;
static PyObject *__pyx_b;
static PyObject *__pyx_empty_tuple;
static int __pyx_lineno;
static int __pyx_clineno = 0;
static const char * __pyx_cfilenm= __FILE__;
static const char *__pyx_filename;
static const char **__pyx_f;

static void __Pyx_AddTraceback(const char *funcname); /*proto*/

/* Type declarations */
/* Module declarations from helloworld */

static int __pyx_f_10helloworld_hello(int, int); /*proto*/


/* Implementation of helloworld */

/* "/home/nosklo/devel/ctest/hello.pyx":1
 * cdef int hello(int a, int b):             # <<<<<<<<<<<<<<
 *     return a + b
 * 
 */

static  int __pyx_f_10helloworld_hello(int __pyx_v_a, int __pyx_v_b) {
  int __pyx_r;

  /* "/home/nosklo/devel/ctest/hello.pyx":2
 * cdef int hello(int a, int b):
 *     return a + b             # <<<<<<<<<<<<<<
 * 
 */
  __pyx_r = (__pyx_v_a + __pyx_v_b);
  goto __pyx_L0;

  __pyx_r = 0;
  __pyx_L0:;
  return __pyx_r;
}

static struct PyMethodDef __pyx_methods[] = {
  {0, 0, 0, 0}
};

static void __pyx_init_filenames(void); /*proto*/

#if PY_MAJOR_VERSION >= 3
static struct PyModuleDef __pyx_moduledef = {
    PyModuleDef_HEAD_INIT,
    "helloworld",
    0, /* m_doc */
    -1, /* m_size */
    __pyx_methods /* m_methods */,
    NULL, /* m_reload */
    NULL, /* m_traverse */
    NULL, /* m_clear */
    NULL /* m_free */
};
#endif
static int __Pyx_InitCachedBuiltins(void) {
  return 0;
  return -1;
}

static int __Pyx_InitGlobals(void) {
  return 0;
  return -1;
}

#if PY_MAJOR_VERSION < 3
PyMODINIT_FUNC inithelloworld(void); /*proto*/
PyMODINIT_FUNC inithelloworld(void)
#else
PyMODINIT_FUNC PyInit_helloworld(void); /*proto*/
PyMODINIT_FUNC PyInit_helloworld(void)
#endif
{
  __pyx_empty_tuple = PyTuple_New(0); 
  if (unlikely(!__pyx_empty_tuple))
      {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; 
       __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  /*--- Library function declarations ---*/
  __pyx_init_filenames();
  /*--- Initialize various global constants etc. ---*/
  if (unlikely(__Pyx_InitGlobals() < 0)) 
     {__pyx_filename = __pyx_f[0]; 
      __pyx_lineno = 1; 
      __pyx_clineno = __LINE__; 
      goto __pyx_L1_error;}
  /*--- Module creation code ---*/
  #if PY_MAJOR_VERSION < 3
  __pyx_m = Py_InitModule4("helloworld", __pyx_methods, 0, 0, PYTHON_API_VERSION);
  #else
  __pyx_m = PyModule_Create(&__pyx_moduledef);
  #endif
  if (!__pyx_m) 
     {__pyx_filename = __pyx_f[0]; 
      __pyx_lineno = 1; __pyx_clineno = __LINE__; 
      goto __pyx_L1_error;};
  #if PY_MAJOR_VERSION < 3
  Py_INCREF(__pyx_m);
  #endif
  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME);
  if (!__pyx_b) 
     {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; 
      __pyx_clineno = __LINE__; goto __pyx_L1_error;};
  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) 
      {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; 
       __pyx_clineno = __LINE__; goto __pyx_L1_error;};
  /*--- Builtin init code ---*/
  if (unlikely(__Pyx_InitCachedBuiltins() < 0)) 
      {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; 
       __pyx_clineno = __LINE__; goto __pyx_L1_error;}
  __pyx_skip_dispatch = 0;
  /*--- Global init code ---*/
  /*--- Function export code ---*/
  /*--- Type init code ---*/
  /*--- Type import code ---*/
  /*--- Function import code ---*/
  /*--- Execution code ---*/

  /* "/home/nosklo/devel/ctest/hello.pyx":1
 * cdef int hello(int a, int b):             # <<<<<<<<<<<<<<
 *     return a + b
 * 
 */
  #if PY_MAJOR_VERSION < 3
  return;
  #else
  return __pyx_m;
  #endif
  __pyx_L1_error:;
  __Pyx_AddTraceback("helloworld");
  #if PY_MAJOR_VERSION >= 3
  return NULL;
  #endif
}

static const char *__pyx_filenames[] = {
  "hello.pyx",
};

/* Runtime support code */

static void __pyx_init_filenames(void) {
  __pyx_f = __pyx_filenames;
}

#include "compile.h"
#include "frameobject.h"
#include "traceback.h"

static void __Pyx_AddTraceback(const char *funcname) {
    PyObject *py_srcfile = 0;
    PyObject *py_funcname = 0;
    PyObject *py_globals = 0;
    PyObject *empty_string = 0;
    PyCodeObject *py_code = 0;
    PyFrameObject *py_frame = 0;

    #if PY_MAJOR_VERSION < 3
    py_srcfile = PyString_FromString(__pyx_filename);
    #else
    py_srcfile = PyUnicode_FromString(__pyx_filename);
    #endif
    if (!py_srcfile) goto bad;
    if (__pyx_clineno) {
        #if PY_MAJOR_VERSION < 3
        py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, 
             __pyx_cfilenm, __pyx_clineno);
        #else
        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, 
             __pyx_cfilenm, __pyx_clineno);
        #endif
    }
    else {
        #if PY_MAJOR_VERSION < 3
        py_funcname = PyString_FromString(funcname);
        #else
        py_funcname = PyUnicode_FromString(funcname);
        #endif
    }
    if (!py_funcname) goto bad;
    py_globals = PyModule_GetDict(__pyx_m);
    if (!py_globals) goto bad;
    #if PY_MAJOR_VERSION < 3
    empty_string = PyString_FromStringAndSize("", 0);
    #else
    empty_string = PyBytes_FromStringAndSize("", 0);
    #endif
    if (!empty_string) goto bad;
    py_code = PyCode_New(
        0,            /*int argcount,*/
        #if PY_MAJOR_VERSION >= 3
        0,            /*int kwonlyargcount,*/
        #endif
        0,            /*int nlocals,*/
        0,            /*int stacksize,*/
        0,            /*int flags,*/
        empty_string, /*PyObject *code,*/
        __pyx_empty_tuple,  /*PyObject *consts,*/
        __pyx_empty_tuple,  /*PyObject *names,*/
        __pyx_empty_tuple,  /*PyObject *varnames,*/
        __pyx_empty_tuple,  /*PyObject *freevars,*/
        __pyx_empty_tuple,  /*PyObject *cellvars,*/
        py_srcfile,   /*PyObject *filename,*/
        py_funcname,  /*PyObject *name,*/
        __pyx_lineno,   /*int firstlineno,*/
        empty_string  /*PyObject *lnotab*/
    );
    if (!py_code) goto bad;
    py_frame = PyFrame_New(
        PyThreadState_GET(), /*PyThreadState *tstate,*/
        py_code,             /*PyCodeObject *code,*/
        py_globals,          /*PyObject *globals,*/
        0                    /*PyObject *locals*/
    );
    if (!py_frame) goto bad;
    py_frame->f_lineno = __pyx_lineno;
    PyTraceBack_Here(py_frame);
bad:
    Py_XDECREF(py_srcfile);
    Py_XDECREF(py_funcname);
    Py_XDECREF(empty_string);
    Py_XDECREF(py_code);
    Py_XDECREF(py_frame);
}

/* Type Conversion Functions */

static INLINE Py_ssize_t __pyx_PyIndex_AsSsize_t(PyObject* b) {
  Py_ssize_t ival;
  PyObject* x = PyNumber_Index(b);
  if (!x) return -1;
  ival = PyInt_AsSsize_t(x);
  Py_DECREF(x);
  return ival;
}

static INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
   if (x == Py_True) return 1;
   else if (x == Py_False) return 0;
   else return PyObject_IsTrue(x);
}

static INLINE PY_LONG_LONG __pyx_PyInt_AsLongLong(PyObject* x) {
    if (PyInt_CheckExact(x)) {
        return PyInt_AS_LONG(x);
    }
    else if (PyLong_CheckExact(x)) {
        return PyLong_AsLongLong(x);
    }
    else {
        PY_LONG_LONG val;
        PyObject* tmp = PyNumber_Int(x); if (!tmp) return (PY_LONG_LONG)-1;
        val = __pyx_PyInt_AsLongLong(tmp);
        Py_DECREF(tmp);
        return val;
    }
}

static INLINE unsigned PY_LONG_LONG __pyx_PyInt_AsUnsignedLongLong(PyObject* x) {
    if (PyInt_CheckExact(x)) {
        long val = PyInt_AS_LONG(x);
        if (unlikely(val < 0)) {
            PyErr_SetString(PyExc_TypeError, "Negative assignment to unsigned type.");
            return (unsigned PY_LONG_LONG)-1;
        }
        return val;
    }
    else if (PyLong_CheckExact(x)) {
        return PyLong_AsUnsignedLongLong(x);
    }
    else {
        PY_LONG_LONG val;
        PyObject* tmp = PyNumber_Int(x); if (!tmp) return (PY_LONG_LONG)-1;
        val = __pyx_PyInt_AsUnsignedLongLong(tmp);
        Py_DECREF(tmp);
        return val;
    }
}


static INLINE unsigned char __pyx_PyInt_unsigned_char(PyObject* x) {
    if (sizeof(unsigned char) < sizeof(long)) {
        long long_val = __pyx_PyInt_AsLong(x);
        unsigned char val = (unsigned char)long_val;
        if (unlikely((val != long_val)  || (long_val < 0))) {
            PyErr_SetString(PyExc_OverflowError, "value too large to convert to unsigned char");
            return (unsigned char)-1;
        }
        return val;
    }
    else {
        return __pyx_PyInt_AsLong(x);
    }
}

static INLINE unsigned short __pyx_PyInt_unsigned_short(PyObject* x) {
    if (sizeof(unsigned short) < sizeof(long)) {
        long long_val = __pyx_PyInt_AsLong(x);
        unsigned short val = (unsigned short)long_val;
        if (unlikely((val != long_val)  || (long_val < 0))) {
            PyErr_SetString(PyExc_OverflowError, "value too large to convert to unsigned short");
            return (unsigned short)-1;
        }
        return val;
    }
    else {
        return __pyx_PyInt_AsLong(x);
    }
}

static INLINE char __pyx_PyInt_char(PyObject* x) {
    if (sizeof(char) < sizeof(long)) {
        long long_val = __pyx_PyInt_AsLong(x);
        char val = (char)long_val;
        if (unlikely((val != long_val) )) {
            PyErr_SetString(PyExc_OverflowError, "value too large to convert to char");
            return (char)-1;
        }
        return val;
    }
    else {
        return __pyx_PyInt_AsLong(x);
    }
}

static INLINE short __pyx_PyInt_short(PyObject* x) {
    if (sizeof(short) < sizeof(long)) {
        long long_val = __pyx_PyInt_AsLong(x);
        short val = (short)long_val;
        if (unlikely((val != long_val) )) {
            PyErr_SetString(PyExc_OverflowError, "value too large to convert to short");
            return (short)-1;
        }
        return val;
    }
    else {
        return __pyx_PyInt_AsLong(x);
    }
}

static INLINE int __pyx_PyInt_int(PyObject* x) {
    if (sizeof(int) < sizeof(long)) {
        long long_val = __pyx_PyInt_AsLong(x);
        int val = (int)long_val;
        if (unlikely((val != long_val) )) {
            PyErr_SetString(PyExc_OverflowError, "value too large to convert to int");
            return (int)-1;
        }
        return val;
    }
    else {
        return __pyx_PyInt_AsLong(x);
    }
}

static INLINE long __pyx_PyInt_long(PyObject* x) {
    if (sizeof(long) < sizeof(long)) {
        long long_val = __pyx_PyInt_AsLong(x);
        long val = (long)long_val;
        if (unlikely((val != long_val) )) {
            PyErr_SetString(PyExc_OverflowError, "value too large to convert to long");
            return (long)-1;
        }
        return val;
    }
    else {
        return __pyx_PyInt_AsLong(x);
    }
}

static INLINE signed char __pyx_PyInt_signed_char(PyObject* x) {
    if (sizeof(signed char) < sizeof(long)) {
        long long_val = __pyx_PyInt_AsLong(x);
        signed char val = (signed char)long_val;
        if (unlikely((val != long_val) )) {
            PyErr_SetString(PyExc_OverflowError, "value too large to convert to signed char");
            return (signed char)-1;
        }
        return val;
    }
    else {
        return __pyx_PyInt_AsLong(x);
    }
}

static INLINE signed short __pyx_PyInt_signed_short(PyObject* x) {
    if (sizeof(signed short) < sizeof(long)) {
        long long_val = __pyx_PyInt_AsLong(x);
        signed short val = (signed short)long_val;
        if (unlikely((val != long_val) )) {
            PyErr_SetString(PyExc_OverflowError, "value too large to convert to signed short");
            return (signed short)-1;
        }
        return val;
    }
    else {
        return __pyx_PyInt_AsLong(x);
    }
}

static INLINE signed int __pyx_PyInt_signed_int(PyObject* x) {
    if (sizeof(signed int) < sizeof(long)) {
        long long_val = __pyx_PyInt_AsLong(x);
        signed int val = (signed int)long_val;
        if (unlikely((val != long_val) )) {
            PyErr_SetString(PyExc_OverflowError, "value too large to convert to signed int");
            return (signed int)-1;
        }
        return val;
    }
    else {
        return __pyx_PyInt_AsLong(x);
    }
}

static INLINE signed long __pyx_PyInt_signed_long(PyObject* x) {
    if (sizeof(signed long) < sizeof(long)) {
        long long_val = __pyx_PyInt_AsLong(x);
        signed long val = (signed long)long_val;
        if (unlikely((val != long_val) )) {
            PyErr_SetString(PyExc_OverflowError, "value too large to convert to signed long");
            return (signed long)-1;
        }
        return val;
    }
    else {
        return __pyx_PyInt_AsLong(x);
    }
}

static INLINE long double __pyx_PyInt_long_double(PyObject* x) {
    if (sizeof(long double) < sizeof(long)) {
        long long_val = __pyx_PyInt_AsLong(x);
        long double val = (long double)long_val;
        if (unlikely((val != long_val) )) {
            PyErr_SetString(PyExc_OverflowError, "value too large to convert to long double");
            return (long double)-1;
        }
        return val;
    }
    else {
        return __pyx_PyInt_AsLong(x);
    }
}
7 голосов
/ 02 июля 2010

Наблюдение: на основании сравнительного анализа, проведенного разработчиками pybindgen, нет существенной разницы между boost.python и swig. Я не сделал свой собственный тест, чтобы проверить, насколько это зависит от правильного использования функциональности boost.python.

Обратите также внимание, что может быть причина, по которой pybindgen в общем случае работает немного быстрее, чем swig и boost.python: он может не производить столь же универсальное связывание, как два других. Например, распространение исключений, проверка типа аргумента вызова и т. Д. У меня еще не было возможности использовать pybindgen, но я собираюсь это сделать.

Boost - это довольно большой пакет для установки, и в последний раз я видел, что вы не можете просто установить Boost Python, вам в значительной степени нужна вся библиотека Boost. Как уже упоминали другие, компиляция будет медленной из-за интенсивного использования шаблонного программирования, что также обычно означает довольно загадочные сообщения об ошибках во время компиляции.

Резюме: учитывая простоту установки и использования SWIG, он генерирует надежное и универсальное приличное связывание, и что один интерфейсный файл позволяет вашей C ++ DLL быть доступной на нескольких других языках, таких как LUA, C # и Java, Я предпочел бы это по сравнению с boost.python. Но если вам действительно не нужна многоязыковая поддержка, я бы внимательно посмотрел на PyBindGen из-за его предполагаемой скорости и уделил пристальное внимание надежности и универсальности создаваемой им привязки.

6 голосов
/ 26 января 2009

Так как вас интересуют скорость и накладные расходы, я предлагаю рассмотреть PyBindGen .

У меня есть опыт использования его для создания большой внутренней библиотеки C ++. После попытки SWIG, SIP и Boost.Python я предпочитаю PyBindGen по следующим причинам:

  1. Оболочка PyBindGen является чисто Python, нет необходимости изучать другой формат файла
  2. PyBindGen генерирует вызовы Python C API напрямую, не существует слоя косвенного ограничения, грабящего скорость, как SWIG.
  3. Сгенерированный код на C прост и понятен. Мне тоже нравится Cython, но иногда бывает сложно прочитать его вывод на C.
  4. Поддерживаются контейнеры последовательности STL (мы используем много std :: vector's)
5 голосов
/ 20 января 2009

Здесь будут драконы. Не глотай, не повышайся. Для любого сложного проекта код, который вы должны заполнить самостоятельно, чтобы заставить их работать, быстро становится неуправляемым. Если это простой C API для вашей библиотеки (без классов), вы можете просто использовать ctypes. Это будет легко и безболезненно, и вам не придется тратить часы на просмотр документации для этих проектов-лабиринтовых оболочек, пытаясь найти крошечную заметку о нужной вам функции.

3 голосов
/ 19 января 2009

Прежде чем отказаться от своего кода на Python, взгляните на ShedSkin . Они заявляют о лучшей производительности, чем Psyco, в некотором коде (а также утверждают, что он все еще экспериментальный).

Иначе, есть несколько вариантов привязки кода C / C ++ к python.

Boost требует много времени для компиляции, но на самом деле это самое гибкое и простое в использовании решение.

Я никогда не использовал SWIG, но по сравнению с boost он не так гибок, как универсальная инфраструктура привязки, а не платформа, предназначенная для python.

Следующий выбор: Pyrex . Это позволяет писать псевдо-Python-код, который компилируется как расширение C.

3 голосов
/ 19 января 2009

Если это не большое расширение, Boost :: python также может быть опцией, он выполняется быстрее, чем Swig, потому что вы контролируете, что происходит, но это займет больше времени для dev.

В любом случае накладные расходы swig приемлемы, если объем работы за один вызов достаточно велик. Например, если вы столкнулись с тем, что у вас есть какой-то логический блок среднего размера, который вы хотите переместить на C / C ++, но этот блок вызывается внутри замкнутого цикла, часто вам, возможно, придется избегать swig, но я не могу думать любых реальных примеров, кроме скриптовых графических шейдеров.

0 голосов
/ 28 мая 2019

На эту тему стоит прочитать статью Cython, pybind11, cffi - какой инструмент выбрать?

Краткий обзор для нетерпеливых:

  • Cython компилирует ваш Python в C / C ++, позволяя вам встраивать ваш C / C ++ в код Python. Использует статическое связывание. Для программистов на Python.

  • pybind11 (и boost.python) - противоположность. Свяжите свои вещи во время компиляции со стороны C ++. Для программистов на C ++.

  • CFFI позволяет динамически связывать нативный материал во время выполнения. Простой в использовании, но более высокий уровень производительности.

...