Arquivos

Archive for sábado, 5 nov 2011; \44\UTC\UTC\k 44

Extendendo Python com C/C++ via PyBindGen e CTypes

sábado, 5 nov 2011; \44\UTC\UTC\k 44 6 comentários

Depois de um tempo sem postar no Ars Physica vim postar sobre algo totalmente diferente do que eu costumo escrever por aqui: programação. Como grande parte dos físicos hoje em dia, meu dia-a-dia consiste em grande parte em escrever programas de computador para resolver problemas e fazer cálculos. Todo começo de projeto de programação impõe um dilema para quem vai dedicar as próximas semanas (ou meses, anos…) escrevendo uma nova ferramenta: que linguagem de programação usar? Eu escolhi a combinação de C/C++ e Python.

As razões para essa escolha são muitas: Python é uma linguagem bastante simples, que permite prototipagem rápida e desenvolvimento de soluções com pouca dor de cabeça, e com uma ampla gama de módulos e bibliotecas prontas para os mais diversos fins (numpy, scipy, matplotlib, entre centenas de outras…). Entretanto código escrito puramente em Python é extremamente lento, por diversas razões. Isso faz com que não seja possível escrever uma simulação em python puro se pretende-se ter resultado em um tempo razoável. O ideal portanto é usar como cavalo de carga uma outra linguagem, que seja capaz de produzir binários eficientes, que rodem rápido no seu computador. Essa linguagem deve ser usada nas partes onde eficiência e tempo de execução são críticos, enquanto o Python pode ser usado para lidar com partes que geralmente são chatas de se fazer nessas linguagens de mais baixo nível: lidar com strings, arquivos, operações de sistema, geração de código, parsing,…

Como exemplo, no meu atual projeto no doutorado eu uso C/C++ para fazer uma simulação de Monte Carlo, e o Python para organizar as simulações, rodar a simulação para diversos valores de parâmetros diferentes, salvar os resultados em arquivos organizadinhos, enviar os processos para rodar nos diversos nós do cluster do departamento, etc.

Existem dezenas de formas de integrar Python com outras linguagens, de C/C++ e Fortran até Haskell e Emacs Lisp. Entretanto até hoje eu usava a mais boba: compilava um programa em C ou C++ que aceitava parâmetros de linha de comando, e de dentro do código do python abria um pipe para chamar o executável C com os parâmetros adequados com uma chamada de sistema. É uma gambiarra que funciona, mas não deixa de ser uma gambiarra. O ideal é compilar o seu código como uma biblioteca compartilhada que exporta objetos que o interpretador do Python consegue ler. A forma padrão de fazer isso é importar o cabeçalho ‘Python.h’ e usar o API contido lá para criar esses objetos. Isso não é exatamente difícil de fazer, mas é um trabalho sacal e bem repetitivo. É bom ter formas de automatizar esse trabalho e apenas se preocupar em escrever bem seu código em C, sem se preocupar se ele vai ser ou não carregado no python depois.

CTypes

Se o seu código é em C (e não C++) a maneira mais fácil de fazer isso é usando o CTypes – um módulo presente na biblioteca padrão do Python capaz de carregar bibliotecas compartilhadas feitas em C. Por exemplo, suponha que você deseja criar uma função que some dois inteiros e retorne o resultado. O código fonte está nos arquivos teste.h e teste.c:

//arquivo: teste.h
int add(int x, int y);

//arquivo: teste.c
#include "teste.h"
int add(int x, int y){
  return (x + y);
}

Note que esse é um código em C “vanilla”, sem nenhuma referência ao fato de que ele será depois usado no Python. Tudo o que é preciso para disponibilizar a função ‘add’ no python é compilar esse código como uma biblioteca compartilhada:

gcc -fPIC -o libteste.o -c teste.c
gcc -shared -o libteste.so libteste.o

Isso deve gerar um arquivo ‘libteste.so’, que é um binário que possui as instruções da função ‘int add(int, int)’ de forma que pode ser acessado por outros binários em C. Para chamar esse binário dentro do Python com o CTypes é muito fácil:

from ctypes import cdll

libteste = cdll.LoadLibrary("./libteste.so")
# eh necessario passar o caminho completo para o binario pois ele nao esta no PYTHONPATH
x = libteste.add(5, 2)
print x

Esse script deve retornar o valor ’7′, conforme esperado. Difícil, né?

Quando sua função retorna um tipo que não seja ‘int’, é necessário ainda informar ao Python qual é o tipo adequado para converter os objetos do python antes de passá-los para a função em C. O CTypes oferece uma gama de tipos correspondentes a todos os tipos que podem ser criados em C padrão:

Tipo no CType Tipo no C Tipo no Python
c_bool _Bool bool (1)
c_char char 1-character string
c_uint unsigned int int/long
c_long long int/long
c_float float float
c_double double float
c_char_p char * (NUL terminated) string or None

Por exemplo, considere a seguinte função:

//arquivo: teste.h
double c_raizq(double x);

//arquivo: teste.c
#include <math.h>
#include "teste.h"

double c_raizq(double x){
  return sqrt(x);
}

Nesse caso, ao abrir a biblioteca (compilada exatamente como antes) será necessário dar mais informação a respeito dos tipos dessa função:

from ctypes import cdll
from ctypes import *

libtest = cdll.LoadLibrary("./libtest.so")
raiz = libtest.c_raizq
raiz.restype  = c_double
raiz.argtypes = [c_double]

x = raiz(2)

print x

Toda função importada do C tem as duas propriedades ‘restype’ – que é o tipo que a função deve retornar – e ‘argtypes’ – que é uma lista dos tipos que essa função recebe como parâmetros, na ordem em que eles aparecem no código em C.

Quando for necessário usar ponteiros, arrays, structs ou enums, a coisa pode ficar um pouquinho mais complicada, mas nada que faça o código crescer muito mais do que isso. Por exemplo, suponha que queremos exportar o seguinte código para o Python:

//arquivo: teste.h

struct cvec{
  double x;
  double y;
};

typedef struct cvec vector;
double norm(vector * point);  

//arquivo: teste.c

#include "teste.h"
#include <math.h>

double norm(vector * point){
  return sqrt(point->x * point->x + point->y * point->y);
}

Precisamos de uma estrutura similar ao struct ‘vector’ e de portar a função ‘norm’. Note que o argumento dessa função é um ponteiro para a struct vector. O código Python para fazer isso segue abaixo:

from ctypes import cdll
from ctypes import *

#imitando a struct vector 
class vector(Structure):
    _fields_ = [("x", c_double) ,
                ("y", c_double)]

libtest = cdll.LoadLibrary("./libtest.so")
norm = libtest.norm
norm.restype  = c_double
norm.argtypes = [POINTER(vector)]

vecc = vector(5,2)
print norm(pointer(vecc))

A classe vector imita a estrutura do struct vector, e as funções POINTER e pointer são usadas respectivamente para informar que o tipo do argumento é um ponteiro e obter um ponteiro para o objeto ‘vecc’. Structs e unions deve ser replicadas no Python por classes que herdam das superclasses Structure e Union, respectivamente.

Enfim, o CTypes fornece um API completo para usar qualquer código C padrão dentro do Python com um mínimo de boilerplate e nenhuma interferência no código original. Não é preciso reescrever suas funções nem entender a estrutura do API do Python. Apenas compilar seu código como uma biblioteca compartilhada.

PyBindGen

Infelizmente o CTypes não é capaz de ler binários de C++. A razão é simples: não existe um padrão para os binários de C++ e cada compilador implementa interfaces diferentes para seus binários. A esperança é que com o estabelecimento do padrão C++11 isso possa ser resolvido, mas isso é uma questão para o futuro. No entanto existe uma biblioteca feita em Python capaz de gerar bindings de códigos em C++ sem interferir no código e com o mínimo de esforço. Por exemplo, suponha que temos uma classe feita em C++ que representa pontos em 2 dimensões, com alguns métodos úteis:

//arquivo Vector.hpp
#include <cmath>
class Vector {
private:
  double x;
  double y;
public:
  Vector(double _x, double _y) : x(_x), y(_y) {}; //construtor

  double norm();               // retorna tamanho do vector
  void reflectO();           // reflete o vetor através da origem
  void rotate(double theta); // roda o vetor em torno da origem por um angulo theta
};

//arquivo Vector.cpp
#include "Vector.hpp"

double Vector::norm() {
  return x*x + y*y;
}

void Vector::reflectO(){
  x = -x;
  y = -y;x
}

void Vector::rotate(double theta){
  double xx = cos(theta) * x - sin(theta) * y;
  double yy = sin(theta) * x + cos(theta) * y;
  x = xx;
  y = yy;
}

Essa classe cria um vetor com duas componentes, com métodos que calculam a norma, refletem o vetor através da origem e rodam por um certo angulo. Para tornar essa classe disponível para o Python é preciso criar um script que gera automaticamente os bindings que devem ser então compilados em um módulo. A estrutura do script é bem simples – primeiro você deve criar um módulo e adicionar ao módulo a classe que deseja exportar, e em seguida adicionar os métodos à classe:

#arquivo: setupBinding.py
#! /usr/bin/env python

import sys
import pybindgen
from pybindgen import param, retval

#Modulo Vector
mod = pybindgen.Module("Vector")

#o modulo inclui o header Vector.hpp
mod.add_include('"Vector.hpp"')

#Adicionando a classe:
klass = mod.add_class('Vector')

#Adicionando o construtor:
klass.add_constructor([param('double', '_x'), param('double', '_y')])

#Adicionando os metodos:
klass.add_method('norm', retval('double'), [])
klass.add_method('reflectO', None, [])
klass.add_method('rotate'  , None, [param('double', 'theta')])

#imprime o binding na tela
mod.generate(sys.stdout)

Note a sintaxe dos comandos:

  • add_constructor([param('tipo', 'nome'),…]) – essa função recebe uma lista com os parametros que o construtor recebe. Se houver mais de um construtor, eles devem ser todos adicionados em sequencia.
  • add_method(‘nome’, retval(‘tipo de retorno’), [param('tipo_do_parametro1', 'nome1'), …]) – essa função recebe o nome do método, o tipo do valor que o método retorna e uma lista com os tipos dos parametros de entrada.

Ao rodar esse script com ‘python setupBinding.py’, ele imprime na tela um código em C que é um binding para o código contido em ‘Vector.cpp’ e ‘Vector.hpp’. Ao compilar esses bindings, teremos um módulo Vector que pode ser importado dentro do python como qualquer outro módulo:

import Vector

foo = Vector.Vector(1,2)
print foo.norm()
foo.rotate(0.2)

Compilar esse módulo é só um pouquinho mais complicado do que no caso do CTypes. Em primeiro lugar é preciso compilar uma biblioteca compartilhada como anteriormente:

g++ -fPIC -c -o libvector.o  Vector.cpp
g++ -shared  -o libvector.so libvector.o

sh Isso cria os arquivos ‘libvector.o’ e ‘libvector.so’. E então devemos gerar os bindings:

python setupBinding.py > bindVector.c

sh E compilar uma biblioteca compartilhada com os bindings:

g++ -fPIC -I/usr/include/python2.7 -c -o bindVector.o bindVector.c
g++ -shared -o Vector.so -L. -lvector bindVector.o

Note que é preciso passar para o compilador o caminho para os headers do python no seu sistema – no meu caso a versão 2.7 do python no linux está em ‘usr/include/python2.7‘. Também é preciso passar para o linker o caminho atual, onde está os arquivos ‘libvector.so’ e ‘libvector.o’ – que é a pasta atual onde a compilação está sendo feita. Isso é feito com as flag “-L. -lvector”. Isso cria o arquivo Vector.so, que contém o módulo Python que pode ser carregado através do comando “import”. Note que o nome do arquivo deve ser o mesmo nome do módulo conforme adicionado no script que gerou os bindings.

Antes de tentar importar o arquivo no python, é preciso adicionar o caminho onde o arquivo ‘Vector.so’ se encontra nas variáveis de ambiente PYTHONPATH e LD_LIBRARY_PATH:

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:.
export PYTHONPATH=$PYTHONPATH:.

Agora o módulo Vector pode ser usado normalmente:

import Vector

foo = Vector.Vector(1,2)
print foo.norm()
foo.rotate(0.2)

Enfim. Espero que isso ajude quem, como eu, vem quebrando a cabeça com isso a muito tempo e já testou diversas ferramentas (SWIG, SIP, Cython/Pyrex, Boost::Python, etc, etc, etc… ). As documentações oficiais das ferramentas usadas nesse post podem ser encontradas aqui:

Seguir

Obtenha todo post novo entregue na sua caixa de entrada.

Junte-se a 67 outros seguidores

%d blogueiros gostam disto: