Interface Python/C++ que choisir ? vos avis svp

Bonsoir

Je poste ce message car je cherche m'exercer dans l'interfaçage Python/C++ et je voudrais avoir vos avis sur l'outil "optimal" à utiliser.

J'ai un peu fait joujou avec SWIG (exemple de base sur une fonction) mais en recherchant sur internet, j'ai vu qu'il existait les outils suivants:
- SWIG
- Cython
- SIP
- Boost Python

Quel est celui que vous me conseillerez d'utiliser et pourquoi ? Si vous avez eu l'occasion de vous en servir, pouvez-vous me faire part de vos retours ?

En vous remerciant

Avec C++, celui ayant meilleur réputation est boost, sinon pour l'interfaçage C/python je préfère cython.

Ce qui m'a bloqué avec boost est la doc que je ne trouve pas toujours très clair.

Bref pour C++, boost est très puissant.

SWIG pour l'avoir testé, j'aime pas, pas adhérer, et je ne trouve pas très performant.

SIP pas testé, donc je n'affirme rien.

Bonjour,

Dans la liste donnée, je ne connais que Cython, et je le trouve très intéressant. Comme il y a longtemps que je n'ai pas programmé en C/C++, j'apprécie de ne pas avoir à le faire...

Un des avantages que j'y vois, c'est qu'en utilisant la solution "décorateur", on peut accélérer des fonctions Python sans modifier leur code.

Si on accepte de programmer en Python en visant Cython, on peut utiliser directement les fonctions de la bibliothèque C (la doc parle aussi de C++). Par exemple, pour utiliser la fonction exp dans une fonction compilée Cython, il suffira de la définir comme suit:

Code:

---

1 2	cdef extern from "math.h": double exp(double x)

---

A noter tout de même que le gain en rapidité dépend de la "proximité" du codage Python par rapport au C. Par exemple, si on utilise à fond les structures de données Python qui n'existent pas en C (le "long" de Python par exemple), on oblige le code compilé à faire appel en permanence à l'API Python, ce qui fait qu'on ne gagne plus rien.

Prenons un exemple: une fonction Python qui calcule e à la puissance x en passant par les séries.

1- version en pur Python:

Code:

---

1 2 3 4 5 6 7 8

def expo1(x, eps=1e-15): """calcul de e puissance x par les séries""" n, t, s = 0, 1.0, 1.0 while t/s>eps: n += 1 t = t*x/n s = s + t return s

---

2- version en Cython avec la solution "décorateur" => dans un fichier séparé appelé ici "test01bib.pyx" :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

from cython import cclass, ccall, cfunc, returns as creturns, locals as clocals ############################################################################# @ccall @creturns(double) @clocals(x=double, eps=double, n=int, t=double, s=double) def expo2(x, eps=1e-15): """calcul de e puissance x par les séries""" n, t, s = 0, 1.0, 1.0 while t/s>eps: n += 1 t = t*x/n s = s + t return s

---

le décorateur "ccall" indique le type de fonction. Ici, ce sera une fonction qu'on pourra appeler à partir du C et à partir du Python. Il y a d'autres types: "cclass" pour une classe et "cfunc" pour appel uniquement à partir du C.

Le reste est évident: on précise les types de données utilisées pour que le compilateur C sache quoi faire.

On compile avec (ce qui fabrique "test01bib.pxd"):

Code:

---

python setup.py build_ext --inplace

---

Avec un setup.py qui contient (NB: pas de caractères accentués, même dans les commentaires!):

Code:

---

1 2 3 4 5 6 7 8 9 10 11

from distutils.core import setup from distutils.extension import Extension from Cython.Distutils import build_ext   ext_modules = [Extension("test01bib", ["test01bib.pyx"])]   setup( name = 'bibliotheque', cmdclass = {'build_ext': build_ext}, ext_modules = ext_modules )

---

Et on importe cette fonction compilée avec (elle sera extraite directement de "test01bib.pyd"):

Code:

---

from test01bib import expo2

---

Voilà. On peut maintenant faire des essais pour comparer la solution en pur Python avec la solution Cython: avec 1 million de valeurs au hasard, la solution Cython est 10 fois plus rapide que la solution Python!

Bonus: sous Windows, comme j'ai Visual C, Cython le prend par défaut. Quand je veux qu'il utilise plutôt mingw32, je place dans le même répertoire un fichier texte appelé "setup.cfg" contenant:

Code:

---

1 2	[build] compiler = mingw32

---

[Edit] J'ai dit plus haut qu'on pouvait utiliser directement les fonctions de bibliothèques C/C++. Cela veut dire qu'on peut créer facilement en Python compilé par Cython, une interface pour utiliser des bibliothèques C/C++ et les appeler directement à partir du code en pur Python. Par exemple:

Code:

---

1 2 3 4 5 6 7 8 9 10

cdef extern from "math.h": double exp(double x)   ############################################################################# @ccall # pour appel possible par du C ou par du Python @creturns(double) @clocals(x=double) def exp2(x): """calcul de e puissance x par la bibliothèque C """ return exp(x)

---

Une fois compilé par Cython, ce code permettra à un programme en pur Python, après une simple importation, d'appeler exp2 qui appellera directement le exp de la bibliothèque C.

Salut Tyrtamos,

Si t'as une solution pour faire tourner du code C++ avec cython, je veux bien, du genre utiliser une fonction externe d'une bibliothèque créée en C++ dans un fichier de type pyx, je signe :)

Sinon le C, ça passe nickel avec cython.

Pour le C++, je suis très embêté...

Bonjour fred1599,

J'ai vu seulement que le sujet était abordé assez longuement dans la doc (http://wiki.cython.org/WrappingCPlusPlus).

Il y a de plus un exemple qu'on peut télécharger (http://wiki.cython.org/WrappingCPlus...=cythoncpp.tgz), et qui parait assez simple.

Si tu es dans le bain du C++: essaie, et dis si ça marche! Ça m'intéresse, mais je n'ai pas touché au C++ depuis pas mal de temps (2005) et j'ai "des trous dans mes lacunes" :roll:

Eh bien écoute rien à faire

Voici mon code C++, rien de plus simple

test.cpp

Code:

---

1 2 3 4 5 6

#include <iostream>   int add(int a, int b) { return a+b; }

---

test.h

Code:

---

1 2 3 4 5 6

#ifndef TEST_H_INCLUDED #define TEST_H_INCLUDED   int add(int a, int b);   #endif

---

addition.pyx

Code:

---

1 2 3 4 5 6 7 8 9

cdef extern from "test.h": cdef int add(int, int)     cpdef ajouter(a, b): cdef int val_1 = a cdef int val_2 = b cdef int result = add(val_1, val_2) return result

---

Code:

---

cython addition.pyx --cplus

---

Mon addition.cpp sort sans problème...

setup.py

Code:

---

1 2 3 4 5 6 7 8 9 10 11

from distutils.core import setup, Extension   ext = Extension( "ajout", ["addition.pyx"], language="c++", include_dirs=["/home/fred1599/Desktop"], libraries=['test'], extra_link_args=[], )   setup (ext_modules = [Extension('test', ['test.cpp'])],)

---

Fonctionne bien comme ci-dessous, mais même message d'erreur après l'import de la lib.

Résultat

Code:

---

g++ addition.cpp -o addition.so -shared -pthread -fPIC -fwrapv -O2 -Wall -fno-strict-aliasing $(pkg-config python --cflags)

---

La compilation se passe bien, mais au niveau de l'import

Code:

---

1 2 3 4

>>> import addition Traceback (most recent call last): File "<stdin>", line 1, in <module> ImportError: ./addition.so: undefined symbol: _Z3addii

---

Du coup si j'arrive à faire fonctionner ce petit code, ça roulera pour moi, mais rien à faire, alors qu'en C ça va tout seul.

As-tu essayé l'exemple à télécharger?

Non je vais regarder

J'ai fais quelques modifs, j'ai utilisé un autre setup.py et regardé le makefile, mais rien à faire, j'ai toujours la même erreur lors de l'importation.

Pour que le code Cython dans le .pyx réussisse à appeler la fonction écrite en C++, il faut que cette fonction soit compilée/liée avant en tant que bibliothèque (et non comme un exécutable): comment fais-tu pour ça?

Peut-être faudrait-il avant essayer d'exécuter une fonction de la bibliothèque standard C++? Genre sqrt de math.h?

Citation:

---

Pour que le code Cython dans le .pyx réussisse à appeler la fonction écrite en C++, il faut que cette fonction soit compilée/liée avant en tant que bibliothèque (et non comme un exécutable): comment fais-tu pour ça?

---

cython fichier.pyx --cplus

Citation:

---

Peut-être faudrait-il avant essayer d'exécuter une fonction de la bibliothèque standard C++? Genre sqrt de math.h?

---

C'est plutôt un standard du C, j'ai rien fais de spécial, mon code fonctionne aussi bien en C qu'en C++, si tu vires les includes, non?

Citation:

---

Envoyé par fred1599

cython fichier.pyx --cplus

---

Non. Dans ton exemple perso plus haut, je parle de la compilation de test.cpp accompagné de test.h. Cela m'étonnerait que Cython s'en occupe.

Citation:

---

Non. Dans ton exemple perso plus haut, je parle de la compilation de test.cpp accompagné de test.h. Cela m'étonnerait que Cython s'en occupe.

---

Pourquoi pour le include "test.h" manquant dans le fichier cpp? J'avais fais la modif ça ne change rien.

Ensuite j'ai remodifié pour test.cpp, j'ai fais beaucoup d'autres tests, mais sans réussite.

test.cpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

#include <iostream> #include <cstdio> #include <cstdlib> #include "test.h"   using namespace std;   #ifdef __cplusplus extern "C" { #endif   int add(int a, int b) { return a+b; }   #ifdef __cplusplus } #endif

---

test.h

Code:

---

1 2 3 4 5 6 7 8

#ifndef TEST_H_INCLUDED #define TEST_H_INCLUDED   using namespace std;   int add(int a, int b);   #endif

---

addition.pyx

Code:

---

1 2 3 4 5 6

cdef extern from "test.h": int add(int, int)   cpdef ajouter(x, y): cdef int result = add(x, y) return result

---

cython addition.pyx --cplus

création du fichier addition.cpp

gcc -pthread -fno-strict-aliasing -DNDEBUG -g -fwrapv -O2 -Wall -fPIC -I/usr/include/python2.7 -c /home/fred1599/Desktop/addition.cpp -o /home/fred1599/Desktop/addition.o

Pas d'erreur, cette ligne est récupérée du setup.py

addition.o créé

g++ -pthread -shared -Wl,-O1 -Wl,-Bsymbolic-functions -Wl,-Bsymbolic-functions -Wl,-z,relro /home/fred1599/Desktop/addition.o -o /home/fred1599/Desktop/addition.so

addition.so créé sans erreur

Utilisation de la lib avec python

Code:

---

1 2 3 4

>>> import addition Traceback (most recent call last): File "<stdin>", line 1, in <module> ImportError: ./addition.so: undefined symbol: _Z3addii

---

Voilà toujours la même erreur

C'est toujours non.

test.cpp + test.h ===> test.so

Tu fais comment?

Cython ne s'occupe certainement pas de compiler la bibliothèque C++ contenant les fonctions qui seront considérées comme "extern" par le code Cython.

Citation:

---

Cython ne s'occupe certainement pas de compiler la bibliothèque C++ contenant les fonctions qui seront considérées comme "extern" par le code Cython.

---

Mouais j'ai tenté d'autres choses, donc on sait jamais, bref rien ne fonctionne de ce côté non plus.

Citation:

---

test.cpp + test.h ===> test.so

---

gcc -pthread -fno-strict-aliasing -DNDEBUG -g -fwrapv -O2 -Wall -fPIC -I/usr/include/python2.7 -c test.cpp -o addition.o

Pas d'erreur

g++ -pthread -shared -Wl,-O1 -Wl,-Bsymbolic-functions -Wl,-Bsymbolic-functions -Wl,-z,relro addition.o -o addition.so

pas d'erreur

et ensuite?

Avec:

Code:

---

gcc -pthread -fno-strict-aliasing -DNDEBUG -g -fwrapv -O2 -Wall -fPIC -I/usr/include/python2.7 -c test.cpp -o addition.o

---

Tu envisages de compiler test.cpp en C++ avec gcc? Et que fait là addition.o?

Désolé, mais je crois qu'il y a un problème de méthode. Test.cpp doit être compilé en C++ séparément de "addition". Ceci en mode "bibliothèque", c'est à dire sans le main. Mais je ne sais plus comment on fait.

Bon il y a du nouveau

J'ai utilisé setup.py du tuto

Code:

---

1 2 3 4 5 6 7 8

from distutils.core import setup from Cython.Build import cythonize   setup(ext_modules = cythonize( "addition.pyx", # our Cython source sources=["test.cpp"], # additional source file(s) language="c++", # generate C++ code ))

---

ça me génère un fichier test.so

Maintenant quand j'import j'ai cette erreur

Code:

---

1 2 3 4

>>> import test Traceback (most recent call last): File "<stdin>", line 1, in <module> ImportError: dynamic module does not define init function (inittest)

---

Essaie de t'inspirer de l'exemple à télécharger.

Son setup.py est:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

from distutils.core import setup from distutils.extension import Extension from Cython.Distutils import build_ext   setup( name = 'Demos', ext_modules=[ Extension("rectangle", sources=["rectangle.pyx", "cpp_rect.cpp"], # Note, you can link against a c++ library instead of including the source include_dirs=["."], language="c++"), ], cmdclass = {'build_ext': build_ext},   )

---

Il est donc possible de mettre test.cpp dans le setup, comme il serait aussi possible de mettre sa version compilée séparément test.so. Mais la syntaxe n'est pas la même que la tienne.

J'avais déjà essayé, j'avais la même erreur après une compilation correcte, mais je crois avoir compris le principe, en fait du C++ on va recevoir un fichier de type C grâce au setup.py.

Il me semble que mon erreur se trouve dans mon fichier.pyx, car je ne prend pas en compte le "using namespace std;"

Bref je reverrais cela demain si possible.

Merci pour tout, je te tiens au courant ;)

Bonsoir!

On va y arriver!

Bonjour,

Ça y est!!!

Voilà mon code test:

bib.cpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#include "bib.h"   int add_(int a, int b){ return a+b; }   int pgcd_(int a, int b){ int r; while (b!=0) { r = a%b; a = b; b = r; } return a; }

---

bib.h

Code:

---

1 2	int add_(int a, int b); int pgcd_(int a, int b);

---

calcul.pyx

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

#!/usr/bin/python # -*- coding: utf-8 -*- from __future__ import division # Python 2.7   from cpython cimport bool, list, dict, tuple, long as llong   from cython import cclass, ccall, cfunc, returns as creturns, locals as clocals   cdef extern from "bib.h": cdef int add_(int x, int y) cdef int pgcd_(int a, int b)   ############################################################################# @ccall @creturns(int) @clocals(x=int, y=int) def add(x, y): """addition de x et y""" return add_(x,y)   ############################################################################# @ccall @creturns(int) @clocals(a=int, b=int) def pgcd(a, b): """PGCD de a et de b""" return pgcd_(a,b)

---

setup.py:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

from distutils.core import setup from distutils.extension import Extension from Cython.Distutils import build_ext   ext_modules = [Extension("calcul", sources=["calcul.pyx", "bib.cpp"], include_dirs=["."], language="c++" ) ]   setup( name = 'Demos', ext_modules = ext_modules, cmdclass = {'build_ext': build_ext}, )

---

compilation en console par:

Code:

---

python setup.py build_ext --inplace

---

Ce qui donne "calcul.pyd sous Windows, ou "calcul.so" sous Unix

Utilisation:

Code:

---

1 2 3 4 5 6 7 8 9 10

#!/usr/bin/python # -*- coding: utf-8 -*- from __future__ import division # Python 2.7   from calcul import add, pgcd   print add(7, 11)   print pgcd(56,42)

---

Ce qui donne les bons résultats (18 et 14)

Contrairement à ce que je pensais, la partie de code en C++ (bib.cpp) n'est pas compilée en bibliothèque indépendante, mais liée au code Cython.

J'ai essayé avec Windows (compilateur Visual C++ et mingw32) et Mint13 compatible Ubuntu 12.04: tout fonctionne parfaitement.

A noter que l'exemple à télécharger fonctionne aussi parfaitement, et contient du code plus complexe (classes C++): si nécessaire, il pourrait être intéressant de s'y reporter.

Ok?

[Edit] niveau performance, la solution du pgcd directement codé en C++ est 4 fois plus rapide que la version en Python pourtant déjà rapide (merci Euclide!). Condition d'essai: 1 million de valeurs de a et de b au hasard, comprises entre 100 et 100000.

Salut,

Le wiki Cython contient des tutos montrant comment wrapper C++ ici.

Pour répondre à la question du PO, l'outil le plus efficace dépend du contexte.

Si le seul élément du contexte c'est vous, on peut supposer que vous découvrez ces sujets.

Partez de construction C++ et regardez les difficultés que vous éprouvez à les mettre en œuvre dans un cas ou dans l'autre.
Quelque soit l'outil que vous aurez choisi, pratiquez suffisamment longtemps pour faire le tour du sujet.

Après avoir pris le temps de balayer le sujet avec un de ces outils, passer à un autre ne sera pas un gros soucis: tous ces outils font la même chose seule la mise en œuvre change.
Bon courage,
- W

Bravo Tyrtamos!!!

Je pige pas les import dans le pyx, tu peux m'expliquer d'où ils viennent, j'ai du zapper des choses dans le tuto?

Sinon pourquoi tout ces décorateurs, je n'ai jamais utilisé cela dans un pyx, et dans beaucoup de fichiers exemples, je ne les vois pas non plus.

Bonjour fred1599,

Citation:

---

Envoyé par fred1599

Je pige pas les import dans le pyx, tu peux m'expliquer d'où ils viennent, j'ai du zapper des choses dans le tuto?

---

Pour le 1er:

Code:

---

from cpython cimport bool, list, dict, tuple, long as llong

---

En principe, les types cités dans les déclarations de type sont ceux du C. Il s'agit ici d'introduire les types Python qui pourront être utilisés en Cython (il faudrait aussi "set", etc...). Et le dernier, le "long" de Python, a été rebaptisé par moi "llong" pour éviter le conflit avec le "long" du C (qui n'a pas une longueur arbitraire). Comme je l'ai déjà dit, on peut utiliser les types de Python qui n'existent pas en C, mais plus on le fait et moins c'est rapide. Je suis d'ailleurs déjà tombé sur une fonction plus longue à l'exécution en Cython qu'en pur Python à cause des "long" Python.

Pour le 2e:

Code:

---

from cython import cclass, ccall, cfunc, returns as creturns, locals as clocals

---

Ça va avec les décorateurs:
- type d'objet: cclass: classe; cfunc: fonction appelable uniquement à partir du C; ccall: fonction appelable à partir du C et de Python.
- creturns: déclare le type d'objet en retour.
- clocals: déclare le type des arguments et des variables internes des fonctions.

Citation:

---

Envoyé par fred1599

Sinon pourquoi tout ces décorateurs, je n'ai jamais utilisé cela dans un pyx, et dans beaucoup de fichiers exemples, je ne les vois pas non plus.

---

Parmi toutes les possibilités données par le manuel, j'ai choisi la solution "décorateur" (http://docs.cython.org/src/tutorial/pure.html), et ceci pour une raison très précise: dans le cas général, quand je veux accélérer une fonction Python par Cython, j'ai DEJA le code source Python, et je ne veux pas la réécrire! La solution des décorateurs me permet de ne pas avoir à modifier ce code Python mais seulement d'ajouter les déclarations qui manquent pour que Cython sache comment convertir en C! Je trouve ça très pratique.

J'ai d'ailleurs pris la précaution de vérifier que cette solution n'était pas plus longue à l'exécution que la solution qui oblige à ré-écrire le code. Il n'y a que quelques petits problèmes qui restent à résoudre, comme par exemple les initialisations: quand on déclare que x est un "double" (type C), il faut l'initialiser par x=1.0 et non x=1 qui génère une erreur. Mais c'est seulement un bon réflexe à prendre...

Ce n'est cependant pas une "assurance tout risque", car certains codes en pur Python ne se traduisent pas en Cython, ou ne donnent pas la meilleure performance souhaitée: dans ce cas, mais dans ce cas seulement, il faut repenser le code pour l'adapter à Cython.

Ok, merci Tyrtamos, je vais analyser tes codes, relire la doc, dommage que je sois parti 3 jours, ça va me mettre en haleine pendant tout ce temps. Tu auras sûrement des retours d'ici vendredi ou samedi.

Aussi je souhaiterais chercher une manière plus ressemblante à celle que j'utilisais avec du C et très simple.

Je suis en train de voir du côté de ctypes qui semble bien plus simple pour appeler la lib, je vais chercher.