生産を幸せにするためのpythonモジュールの開発

こんにちは！私は非営利のCyber​​DuckNinjaの開発チームを代表しています。私たちは、バックエンドアプリケーションと機械学習サービスの開発を容易にする製品ファミリー全体を作成およびサポートします。



今日は、PythonをC ++に統合するというトピックに触れたいと思います。







それはすべて、午前2時に友人から電話があり、「負荷がかかっている状態で本番環境があります...」と不平を言ったところから始まりました。会話の中で、本番環境のコードはipyparallel（並列分散コンピューティングを可能にするPythonパッケージ）を使用してモデルを計算して記述されていることがわかりました。オンラインで結果を取得します。 ipyparallelのアーキテクチャを理解し、負荷がかかった状態でプロファイリングを実行することにしました。



このパッケージのすべてのモジュールが完全に設計されていることがすぐに明らかになりましたが、ほとんどの時間はネットワーキング、json解析、およびその他の中間アクションに費やされています。

ipyparallelの詳細な調査の結果、ライブラリ全体が2つの相互作用するモジュールで構成されていることが判明しました。

• タスクの制御とスケジューリングを担当するIpcontroler、
• コードの実行者であるエンジン。

これらのモジュールがpyzmqを介して相互作用するという優れた機能が判明しました。優れたエンジンアーキテクチャのおかげで、ネットワーキングの実装をcppzmq上に構築されたソリューションに置き換えることができました。この置き換えにより、無限の開発範囲が開かれます。対応するものは、アプリケーションのC ++部分で記述できます。



これにより、エンジンプールは理論的にはさらに高速になりましたが、ライブラリをPythonコードに統合する問題は解決されませんでした。ライブラリを統合するために多くのことをしなければならない場合、そのようなソリューションは需要がなく、棚に残ります。現在のエンジンコードベースに開発をネイティブに実装する方法については、疑問が残りました。



開発の容易さ、C ++内でのみAPI宣言、Python内で追加のラッパーを使用しない、ライブラリの全機能をネイティブに使用するなど、どのアプローチを取るかを理解するための合理的な基準が必要でした。そして、PythonでC ++コードをドラッグするネイティブの（そしてそうではない）方法で混乱しないように、少し調査を行いました。2019年の初めに、Pythonを拡張する4つの一般的な方法がインターネット上で見つかりました。

1. Ctypes
2. CFFI
3. Cython
4. CPython API

すべての統合オプションを検討しました。

1.Ctypes

Ctypesは、Cインターフェイスをエクスポートする動的ライブラリをロードできるようにする外部関数インターフェイスです。これを使用すると、PythonのCライブラリ（libev、libpqなど）を使用できます。



たとえば、次のインターフェイスを備えたC ++で記述されたライブラリがあります。

extern "C"
{
    Foo* Foo_new();
    void Foo_bar(Foo* foo);
}

ラッパーを作成します。

import ctypes

lib = ctypes.cdll.LoadLibrary('./libfoo.so')

class Foo:
    def __init__(self) -> None:
        super().__init__()

        lib.Foo_new.argtypes = []
        lib.Foo_new.restype = ctypes.c_void_p
        lib.Foo_bar.argtypes = []
        lib.Foo_bar.restype = ctypes.c_void_p

        self.obj = lib.Foo_new()

    def bar(self) -> None:
        lib.Foo_bar(self.obj)

結論を導き出します。

1. インタプリタAPIと対話できない。Ctypesは、Python側でCライブラリと対話する方法ですが、C / C ++コードがPythonと対話する方法を提供していません。
2. Cスタイルのインターフェイスをエクスポートします。typesはこのスタイルでABIライブラリと対話できますが、他の言語はCラッパーを介してその変数、関数、メソッドをエクスポートする必要があります。
3. ラッパーを作成する必要があります。これらは、CとのABI互換性のためにC ++コード側で、および定型コードの量を減らすためにPython側で作成する必要があります。

typesは私たちに適していません。次の方法であるCFFIを試します。

2. CFFI

CFFIはCtypesに似ていますが、いくつかの追加機能があります。同じライブラリを使用した例を示しましょう。

import cffi

ffi = cffi.FFI()

ffi.cdef("""
    Foo* Foo_new();
    void Foo_bar(Foo* foo);
""")

lib = ffi.dlopen("./libfoo.so")

class Foo:
    def __init__(self) -> None:
        super().__init__()

        self.obj = lib.Foo_new()

    def bar(self) -> None:
        lib.Foo_bar(self.obj)

結論を導き出します



。CFFIには、ラッパーにインターフェイスの定義を指示する必要があるため、ラッパーが少し太くなることを除いて、同じ欠点があります。CFFIも適切ではありません。次の方法であるCythonに移りましょう。

3. Cython

Cythonは、C / C ++とPythonを組み合わせて拡張機能を記述し、その結果を動的ライブラリとしてロードできるようにするサブ/メタプログラミング言語です。今回は、C ++で記述され、インターフェイスを持つライブラリがあります。

#ifndef RECTANGLE_H
#define RECTANGLE_H

namespace shapes {
    class Rectangle {
        public:
            int x0, y0, x1, y1;
            Rectangle();
            Rectangle(int x0, int y0, int x1, int y1);
            ~Rectangle();
            int getArea();
            void getSize(int* width, int* height);
            void move(int dx, int dy);
    };
}

#endif

次に、このインターフェイスをCython言語で定義します。

cdef extern from "Rectangle.cpp":
    pass

# Declare the class with cdef
cdef extern from "Rectangle.h" namespace "shapes":
    cdef cppclass Rectangle:
        Rectangle() except +
        Rectangle(int, int, int, int) except +
        int x0, y0, x1, y1
        int getArea()
        void getSize(int* width, int* height)
        void move(int, int)

そして、それにラッパーを書きます：

# distutils: language = c++

from Rectangle cimport Rectangle

cdef class PyRectangle:
    cdef Rectangle c_rect

    def __cinit__(self, int x0, int y0, int x1, int y1):
        self.c_rect = Rectangle(x0, y0, x1, y1)

    def get_area(self):
        return self.c_rect.getArea()

    def get_size(self):
        cdef int width, height
        self.c_rect.getSize(&width, &height)
        return width, height

    def move(self, dx, dy):
        self.c_rect.move(dx, dy)

    # Attribute access
    @property
    def x0(self):
        return self.c_rect.x0

    @x0.setter
    def x0(self, x0):
        self.c_rect.x0 = x0

    # Attribute access
    @property
    def x1(self):
        return self.c_rect.x1

    @x1.setter
    def x1(self, x1):
        self.c_rect.x1 = x1

    # Attribute access
    @property
    def y0(self):
        return self.c_rect.y0

    @y0.setter
    def y0(self, y0):
        self.c_rect.y0 = y0

    # Attribute access
    @property
    def y1(self):
        return self.c_rect.y1

    @y1.setter
    def y1(self, y1):
        self.c_rect.y1 = y1

これで、通常のPythonコードからこのクラスを使用できます。

import rect
x0, y0, x1, y1 = 1, 2, 3, 4
rect_obj = rect.PyRectangle(x0, y0, x1, y1)
print(dir(rect_obj))

結論を導き出します。

1. Cythonを使用する場合でも、C ++側でラッパーコードを作成する必要がありますが、Cスタイルのインターフェイスをエクスポートする必要はありません。
2. あなたはまだ通訳と対話することはできません。

最後の方法は残っています-CPythonAPI。やってみます。

4. CPython API

CPython API-C ++でPythonインタープリターのモジュールを開発できるようにするAPI。最善の策は、CPythonAPIの操作を便利にする高レベルのC ++ライブラリであるpybind11です。その助けを借りて、C ++で関数、クラスを簡単にエクスポートし、Pythonメモリとネイティブメモリの間でデータを変換できます。



それでは、前の例のコードを取得して、それにラッパーを記述しましょう。

PYBIND11_MODULE(rect, m) {
    py::class_<Rectangle>(m, "PyRectangle")
        .def(py::init<>())
        .def(py::init<int, int, int, int>())
        .def("getArea", &Rectangle::getArea)
        .def("getSize", [](Rectangle &rect) -> std::tuple<int, int> {
            int width, height;

            rect.getSize(&width, &height);

            return std::make_tuple(width, height);
        })
        .def("move", &Rectangle::move)
        .def_readwrite("x0", &Rectangle::x0)
        .def_readwrite("x1", &Rectangle::x1)
        .def_readwrite("y0", &Rectangle::y0)
        .def_readwrite("y1", &Rectangle::y1);
}

ラッパーを作成しました。バイナリライブラリにコンパイルする必要があります。ビルドシステムとパッケージマネージャーの2つが必要です。これらの目的のために、それぞれCMakeとConanを取り上げましょう。



Conanでのビルドを機能させるには、適切な方法でConan自体をインストールする必要があります。

pip3 install conan cmake

追加のリポジトリを登録します。

conan remote add bincrafters https://api.bintray.com/conan/bincrafters/public-conan
conan remote add cyberduckninja https://api.bintray.com/conan/cyberduckninja/conan

conanfile.txtファイルでpybindライブラリのプロジェクトの依存関係を説明しましょう。

[requires]
pybind11/2.3.0@conan/stable

[generators]
cmake

CMakeファイルを追加しましょう。Conanとの統合に注意してください-CMakeが実行されると、conan installコマンドが実行され、依存関係がインストールされ、依存関係データを使用してCMake変数が生成されます。

cmake_minimum_required(VERSION 3.17)

set(project rectangle)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED YES)
set(CMAKE_CXX_EXTENSIONS OFF)

	if (NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
    	message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
    	file(DOWNLOAD "https://raw.githubusercontent.com/conan-io/cmake-conan/v0.15/conan.cmake" "${CMAKE_BINARY_DIR}/conan.cmake")
	endif ()

	set(CONAN_SYSTEM_INCLUDES "On")

	include(${CMAKE_BINARY_DIR}/conan.cmake)

	conan_cmake_run(
        	CONANFILE conanfile.txt
        	BASIC_SETUP
        	BUILD missing
        	NO_OUTPUT_DIRS
	)

find_package(Python3 COMPONENTS Interpreter Development)
include_directories(${PYTHON_INCLUDE_DIRS})
include_directories(${Python3_INCLUDE_DIRS})
find_package(pybind11 REQUIRED)

pybind11_add_module(${PROJECT_NAME} main.cpp )

target_include_directories(
    	${PROJECT_NAME}
    	PRIVATE
    	${NUMPY_ROOT}/include
    	${PROJECT_SOURCE_DIR}/vendor/General_NetSDK_Eng_Linux64_IS_V3.051
    	${PROJECT_SOURCE_DIR}/vendor/ffmpeg4.2.1
)

target_link_libraries(
    	${PROJECT_NAME}
    	PRIVATE
    	${CONAN_LIBS}
)

すべての準備が完了しました。収集しましょう。

cmake . -DCMAKE_BUILD_TYPE=Release 
cmake --build . --parallel 2

結論を導き出します。

1. アセンブルされたバイナリライブラリを受け取りました。これは、後でPythonインタープリターにロードできます。
2. 上記の方法と比較して、コードをPythonにエクスポートするのがはるかに簡単になり、ラッピングコードがよりコンパクトになり、同じ言語で記述されるようになりました。

cpython / pybind11の機能の1つは、C ++ランタイム中にpythonランタイムから関数をロード、取得、または実行することです。その逆も同様です。



簡単な例を見てみましょう。

#include <pybind11/embed.h>  //     

namespace py = pybind11;

int main() {
    py::scoped_interpreter guard{}; //  python vm
    py::print("Hello, World!"); //     Hello, World!
}

pythonインタープリターをC ++アプリケーションとPythonモジュールエンジンに埋め込む機能を組み合わせることで、ipyparallesエンジンコードがコンポーネントの置換を感じないという興味深いアプローチを思いつきました。アプリケーションの場合、ライフサイクルとイベントサイクルがC ++コードで始まり、その後、Pythonインタープリターが同じプロセス内で開始するアーキテクチャを選択しました。



理解するために、私たちのアプローチがどのように機能するかを見てみましょう。

#include <pybind11/embed.h>

#include "pyrectangle.hpp" //  ++  rectangle

using namespace py::literals;
//            rectangle
constexpr static char init_script[] = R"__(
    import sys

    sys.modules['rect'] = rect
)__";
//             rectangle
constexpr static char load_script[] = R"__(
    import sys, os
    from importlib import import_module

    sys.path.insert(0, os.path.dirname(path))
    module_name, _ = os.path.splitext(path)
    import_module(os.path.basename(module_name))
)__";

int main() {
    py::scoped_interpreter guard; //  
    py::module pyrectangle("rect");    

    add_pyrectangle(pyrectangle); //  
    py::exec(init_script, py::globals(), py::dict("rect"_a = pyrectangle)); //        Python.
    py::exec(load_script, py::globals(), py::dict("path"_a = "main.py")); //  main.py

    return 0;
}

上記の例では、pyrectangleモジュールがPythonインタープリターに転送され、rectとしてインポートできるようになります。「カスタム」コードで何も変更されていないことを例を挙げて説明しましょう。

from pprint import pprint

from rect import PyRectangle

r = PyRectangle(0, 3, 5, 8)

pprint(r)

assert r.getArea() == 25

width, height = r.getSize()

assert width == 5 and height == 5

このアプローチは、高い柔軟性と多くのカスタマイズポイント、およびPythonメモリを合法的に管理する機能を特徴としています。ただし、問題があります。エラーのコストは他のオプションよりもはるかに高く、このリスクに注意する必要があります。



したがって、ctypesとCFFIは、Cスタイルのライブラリインターフェイスをエクスポートする必要があるため、またPython側でラッパーを記述し、最終的には埋め込みが必要な場合はCPython APIを使用する必要があるため、適切ではありません。Cythonには輸出上の欠陥はありませんが、他のすべての欠陥は保持されています。Pybind11は、C ++側でのラッパーの埋め込みと書き込みのみをサポートします。また、データ構造を操作したり、Pythonの関数やメソッドを呼び出したりするための広範な機能も備えています。その結果、CPythonAPIの高レベルのC ++ラッパーとしてpybind11を決定しました。



C ++アプリケーション内でのembedpythonの使用と、高速データ転送のためのモジュールメカニズムを組み合わせ、ipyparallelエンジンのコードベースを再利用することで、rocketjoe_engineを取得しました。メカニズムはオリジナルと同じであり、ネットワークインタラクション、json処理、およびその他の中間アクションのキャストを減らすことで、より高速に動作します。これにより、友人はGitHubプロジェクトで最初のスターを獲得したプロダクションに負荷をかけることができます。

Conan, Russian Python Week C++, Python Conan .



Russian Python Week 4 — 14 17 . , Python: Python- . , Python.

.