C-Bibliothek in Python mit ctypes

In diesem Beitrag werde ich beschreiben, wie man eine C-Bibliothek in Python verwenden kann. Dazu werde ich ein Projekt erstellen, die Abhängigkeiten mit Conan verwalten, das Projekt mit CMake bauen und abschließend die generierte Bibliothek in Python verwenden. Als Beispiel wird das Skalarprodukt zweier Vektoren berechnet. Außerdem wird die Korrektheit mit Unit Tests von Boost überprüft. Die Projektstruktur ist wie folgt aufgebaut:

conanfile.txt
CMakeLists.txt
dot_product.py
src/
    DotProduct.cpp
    DotProduct.hpp
test/
    main.cpp
    DotProduct.cpp
build/

Conan

Mit Conan können die Abhängigkeiten in C/C++ Projekten  verwalten werden. In simplen Projekten wie diesem werden die Abhängigkeiten in die Datei conanfile.txt eingetragen und konfiguriert. Die Datei sieht so aus:

[requires] 
boost/1.68.0@conan/stable 

[generators] 
cmake 

[options] 
boost:shared=True

Im Bereich requires wird die Abhängigkeit eingetragen. In diesem Projekt wird Boost in Version 1.68.0 verwendet. Im Bereich generators wird die Art des Projektes und die benötigten Dateien eingetragen. Durch den Eintrag cmake werden Dateien erzeugt, die man mit CMake einbinden kann. Damit werden u. A. die Include- und Library-Pfade gesetzt. Im Bereich options wird festgelegt, dass dynamisch gegen die shared objects von Boost gelinkt werden soll.

CMake

Mit CMake wird das Projekt konfiguriert. CMake ist ein Buildsystem, dass man plattformübergreifend einsetzen kann. Die Konfiguration wird in die Datei CMakeLists.txt eingetragen und sieht wie folgt aus:

cmake_minimum_required (VERSION 3.5.1) 
project (DotProduct) enable_testing() 
set(CMAKE_CXX_STANDARD 14) 
set(CMAKE_BUILD_TYPE Debug) include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) 
conan_basic_setup() 
add_library(DotProduct SHARED src/DotProduct.cpp src/DotProduct.hpp) 
add_executable(tests test/main.cpp test/DotProduct.cpp src/DotProduct.hpp) 
target_include_directories(tests PRIVATE src ${CONAN_INCLUDE_DIRS}) target_link_libraries(tests DotProduct ${CONAN_LIBS}) 
add_test(NAME tests COMMAND tests)

In der ersten Zeile wird die kleinstmögliche Version von CMake eingetragen. In der zweiten Zeile wird der Name des Projekts festgelegt. In der dritten Zeile wird das Testing aktiviert. Dadurch kann man nach dem Build mit ctest die Unit Tests ausführen. In den nächsten beiden Zeilen wird die C++ Version auf C++14 und der Build Type auf Debug gesetzt, damit u. A. Debug-Informationen geschrieben werden.

Die nächsten beiden Zeilen binden von Conan erstellte Datei ein und konfigurieren CMake mit den Einträgen aus der Datei.

Mit add_library wird nun der Build der C-Bibliothek beschrieben, die später in Python verwendet werden soll.

Abschließend wird mit ein add_executable ein Build für die Unit Tests erzeugt, die Include- und Linker-Einstellungen werden angepasst und die Tests werden zu CMake hinzugefügt.

Tests

Im Ordner test werden nun die Dateien für die Tests erstellt. Die Datei test/main.cpp enthält nur einen Rahmen:

#define BOOST_TEST_MODULE Dot_Product 
#define BOOST_TEST_DYN_LINK 
#include <boost/test/unit_test.hpp>

Die eigentlichen Tests befinden sich in der Datei test/DotProduct.cpp:

#define BOOST_TEST_DYN_LINK 
#include <boost/test/unit_test.hpp> 
#include "DotProduct.hpp" 

BOOST_AUTO_TEST_CASE(test_case1) { 
    double vec1[] = {2, 2}, vec2[] = {2, 3}; 
    BOOST_TEST(dotProduct(vec1, vec2, 2) == 10); 
} 

BOOST_AUTO_TEST_CASE(test_case2) { 
    double vec1[] = {-1, 0}, vec2[] = {0, 1}; 
    BOOST_TEST(dotProduct(vec1, vec2, 2) == 0); 
} 

BOOST_AUTO_TEST_CASE(test_case3) { 
    double vec1[] = {1, 1, 1}, vec2[] = {2, -3, 4};
    BOOST_TEST(dotProduct(vec1, vec2, 3) == 3); 
}

Die Bibliothek

Der Quellcode für die eigentliche Bibliothek befindet sich im Ordner src. In der Datei src/DotProduct.hpp wird die Funktion dotProduct deklariert, die das Skalarprodukt berechnet und das Ergebnis als double zurückgibt:

extern "C" double dotProduct(double* l, double* r, unsigned int len);

In der Datei src/DotProduct.cpp wird diese Funktion definiert:

#include "DotProduct.hpp" 

double dotProduct(double *l, double *r, unsigned int len) { 
    double sum(0); 
    
    while (len--) { 
        sum += l[len] * r[len]; 
    } 
    return sum; 
}

Build

Der Build des Projekts erfolgt im Verzeichnis build. Dazu wird das aktuelle Arbeitsverzeichnis mit cd auf build gesetzt. Nun werden zunächst die Abhängigkeiten mit Conan installiert:

conan install .. --build missing

Anschließend wird das CMake Projekt generiert und konfiguriert:

cmake ..

Mit

cmake --build .

werden die Bibliothek und die Unit Tests gebaut. Als letztes sollte die Bibliothek mit den Tests überprüft werden:

ctest

Python

Abschließend soll die Bibliothek in Python verwendet werden. Dazu wird ein Skript in dot_product.py erstellt:

import ctypes

def dot_product(v1, v2):    
    l = len(v1)    
    if l != len(v2):        
        return 0    
    vec1 = (ctypes.c_double * l)(*v1)    
    vec2 = (ctypes.c_double * l)(*v2)    
    Dot_Product = ctypes.CDLL("build/lib/libDotProduct.so")      
    Dot_Product.dotProduct.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.POINTER(ctypes.c_double), ctypes.c_int]    
    Dot_Product.dotProduct.restype = ctypes.c_double
    return Dot_Product.dotProduct(vec1, vec2, l)

vec1 = [2, 2]
vec2 = [2, 3]
print("{} * {} = {}".format(vec1, vec2, dot_product(vec1, vec2)))

Das Modul ctypes wird verwendet, um shared objects zu laden. Zuerst wird eine Funktion erzeugt, der zwei Listen übergeben werden. Am Anfang der Funktion wird überprüft, ob beide Listen die gleiche Länge haben. An dieser Stelle wird der Wert 0 zurückgegeben, wenn sich die Längen unterscheiden. Dies lässt sich durch eine Fehlerbehandlung mit Exceptions verbessern.

Im nächsten Schritt werden die Listen in ctypes-Arrays vom Typ c_double umgewandelt. Danach wird das shared object geladen. Anschließend werden die Typen der Funktionsparameter und des Rückgabewertes festgelegt. Abschließend wird die Funktion aus der C-Bibliothek aufgerufen und das berechnete Skalarprodukt wird zurückgegeben.

Um die neue Python-Funktion zu testen, werden zwei Listen erstellt und als Parameter an diese Funktion übergeben. Natürlich empfehlen sich auch an dieser Stelle automatische Unit Tests.

Fazit

Es wurde ein CMake-Projekt erstellt, in dem die Abhängigkeiten mit Conan verwaltet werden. Im Projekt wurden eine C-Bibliothek und Unit Tests erzeugt. Die Korrektheit der C-Bibliothek wurde getestet und abschließend wurde die Bibliothek in Python verwendet.

ThreadPool

ThreadPool ist eine C++11 Bibliothek zur Nutzung von Threads in einem Thread Pool. Ein Thread Pool wird mit

ThreadPool::ThreadPool(std::size_t anzThreads);

erzeugt. Anschließend können mit

ThreadPool::post(std::function<void()> f)

Threads im Pool gestartet werden. Es laufen immer maximal anzThreads gleichzeitig. Abschließend muss der Thread Pool mit

ThreadPool::join()

auf den Abschluss des letzten Threads warten.

GitHub

sed mit find

sed lässt sich sehr gut mit find kombinieren, um mehrere Dateien gleichzeitig anzupassen. Zunächst muss nach den Dateien gesucht werden, zum Beispiel nach dem Dateinamen mit:

find -name pom.xml

Mit -exec kann nun ein Befehl für jeden Suchtreffer ausgeführt werden. Als Platzhalter für den gefundenen Dateinamen dient hierbei ‚{}‘. Mit ‚;‘ der Befehl abgeschlossen. Um somit die Version in allen Dateien mit dem Namen pom.xml zu aktualisieren, nutzt man

find -name pom.xml -exec sed -i 's/<version>1.31.0-SNAPSHOT<\/version>/<version>1.32.0-SNAPSHOT<\/version>/' '{}' ';'

In dem Beispiel wird der Suchstring „<version>1.31.0-SNAPSHOT</version>“ durch den String „<version>1.32.0-SNAPSHOT</version>“ ersetzt. Durch den Parameter -i wird das Ergebnis direkt in die Datei geschrieben.

sed, ein mächtiger Text Editor

sed ist ein Kommandozeilenwerkzeug, hauptsächlich auf Linuxsystemen eingesetzt. Im Gegensatz zu den meisten Editoren, wie vi oder nano, bewegt man sich nicht mit einem Cursor in einem Text und verändert diesen, sondern man führt Befehle aus, die einzelne Zeilen manipulieren.

Jedem sed Befehl kann ein Bereich vorangestellt werden. Zum Beispiel bezieht sich der Bereich „64, 123“ Zeilen 64 bis 123. Der Befehl zum Ersetzen  von Abschnitten in Zeilen ist „s“. Dem Befehl werden die Parameter mit dem Zeichen „/“ umschlossen angehängt. Der erste Parameter ist ein regulärer Ausdruck, der ersetzt werden soll. Der zweite Parameter ist der Text, der eingefügt werden soll

Mit dem Kommandozeilenbefehl

sed '64, 123s/^/\/\//' main.cpp

werden den Zeilen 64 bis 123 der Datei der Text „//“ vorangestellt. Der erste Parameter ist „^“, der den Zeilenanfang bezeichnet. Der zweite Parameter ist „\/\/“, der maskiert den Text „//“ repräsentiert. Jedoch wird hierbei die Änderung nicht direkt in die Datei geschrieben sondern der Inhalt der verändert Datei wird auf der Standardausgabe ausgegeben.

Mit „{}“ lassen sich Befehle gruppieren. Mit „>“ wird die Ausgabe in eine Datei umgeleitet. Mit

sed '64,123 {s/^/\/\//; s/$/ \/\/ TS/}' main.cpp > new_main.cpp

werden den Zeilen 64 bis 123 der Text „//“ vorangestellt und der Text „// TS“ angehängt. Das Ergebnis wird in die Datei „new_main.cpp“ geschrieben.

Eine weitere Möglichkeit, einzelne Zeilen zu bearbeiten, ist das Adressieren. Dazu wird dem Befehl ein mit dem Zeichen „/“ umschlossener regulärer Ausdruck vorangestellt. Mit dem Zeichen „!“ lässt sich die Auswahl invertieren. Mit

sed '34, 57 {/^$/!{s/^/\/\/ /; s/$/ \/\/ TS/}}' main.cpp > new_main.cpp

wird allen Zeilen im Bereich von Zeile 34 bis Zeile 57, die nicht leer sind, der Text „// “ vorangestellt und der Text “ // TS“ angehängt.

Fix für Eclipse GTK Problem unter Linux

Es gibt ein Problem mit einigen Eclipse Version/Theme Kombinationen und GTK3. Das Problem zeigt sich durch ein unsauberes Aussehen, eine falsche Darstellung von Buttons und der fehlenden Aktualisierung der Menüansicht bei einem Wechsel des Menüpunktes. Auch bleiben einige Ansichten vollständig schwarz. Um das Problem zu beheben, kann man Eclipse mit

env SWT_GTK3=0 eclipse

gestartet werden. Dadurch wird Eclipse mit GTK2 gestartet. Dagegen kann man Eclipse zur Nutzung von GTK3 mit

env SWT_GTK3=1 eclipse

auffordern. Die aktuell verwendete Version kann in Eclipse unter „Help -> About -> Eclipse -> Installation Details -> Configuration -> org.eclipse.swt.internal.gtk.version“ ermittelt werden.

wxOgreView

Eine minimalistische C++ Klasse, die ein Ogre 3D Renderingfenster innerhalb einer wxWidgets Application ermöglicht. Sie kann für unterschiedliche wxWidgets/Ogre Applikationen wie 3D Editoren oder Modelviewer verwendet werden.

Wiki
Github