RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://github.com/compiler-research/CppInterOp below:

compiler-research/CppInterOp: A Clang-based C++ Interoperability Library

CppInterOp exposes API from Clang and LLVM in a backward compatible way. The API support downstream tools that utilize interactive C++ by using the compiler as a service. That is, embed Clang and LLVM as a libraries in their codebases. The API are designed to be minimalistic and aid non-trivial tasks such as language interoperability on the fly. In such scenarios CppInterOp can be used to provide the necessary introspection information to the other side helping the language cross talk.

Installation | Documentation | CppInterOp API Documentation |

The CppInterOp library provides a minimalist approach for other languages to bridge C++ entities (variables, classes, etc.). This enables interoperability with C++ code, bringing the speed and efficiency of C++ to simpler, more interactive languages like Python.

Join our discord for discussions and collaboration.

CppInterOp can be adopted incrementally. While the rest of the framework is the same, a small part of CppInterOp can be utilized. More components may be adopted over time.

While the library includes some tricky code, it is designed to be simple and robust (simple function calls, no inheritance, etc.). The goal is to make it as close to the compiler API as possible, and each routine to do just one thing that it was designed for.

Further Enhancing the Dynamic/Automatic bindings in CPPYY

The main use case for CppInterOp is with the CPPYY service. CPPYY is an automatic run-time bindings generator for Python & C++, and supports a wide range of C++ features (e.g., template instantiation). It operates on demand and generates only what is necessary. It requires a compiler (Cling[^1] /Clang-REPL[^2]) that can be available during program runtime.

Once CppInterOp is integrated with LLVM's[^3] Clang-REPL component (that can then be used as a runtime compiler for CPPYY), it will further enhance CPPYY's performance in the following ways:

Simpler codebase: Removal of string parsing logic will lead to a simpler code base.
LLVM Integration: The CppInterOp interfaces will be a part of the LLVM toolchain (as part of Clang-REPL).
Better C++ Support: C++ features such as Partial Template Specialization will be available through CppInterOp.
Fewer Lines of Code: A lot of dependencies and workarounds will be removed, reducing the lines of code required to execute CPPYY.
Well tested interoperability Layer: The CppInterOp interfaces have full unit test coverage.

'Roots' in High Energy Physics research

Besides being developed as a general-purpose library, one of the long-term goals of CppInterOp is to stay backward compatible and be adopted in the High Energy Physics (HEP) field, as it will become an essential part of the Root framework. Over time, parts of the Root framework can be swapped by this API, adding speed and resilience with it.

Build instructions for CppInterOp and its dependencies are as follows. CppInterOP can be built with either Cling and Clang-REPL, so instructions will differ slightly depending on which option you would like to build, but should be clear from the section title which instructions to follow.

Linux/MacOS Clang-REPL based CppInterOp Clone CppInterOp and cppyy-backend

First clone the CppInterOp repository, as this may contain patches that need to be applied to the subsequently cloned llvm-project repo

git clone --depth=1 https://github.com/compiler-research/CppInterOp.git

and clone cppyy-backend repository where we will be installing the CppInterOp library

git clone --depth=1 https://github.com/compiler-research/cppyy-backend.git

Clone the 20.x release of the LLVM project repository.

git clone --depth=1 --branch release/20.x https://github.com/llvm/llvm-project.git
cd llvm-project

Clang-REPL is an interpreter that CppInterOp works alongside. Build Clang (and Clang-REPL along with it) by executing command

mkdir build 
cd build 
cmake -DLLVM_ENABLE_PROJECTS=clang                                  \
                -DLLVM_TARGETS_TO_BUILD="host;NVPTX"                \
                -DCMAKE_BUILD_TYPE=Release                          \
                -DLLVM_ENABLE_ASSERTIONS=ON                         \
                -DCLANG_ENABLE_STATIC_ANALYZER=OFF                  \
                -DCLANG_ENABLE_ARCMT=OFF                            \
                -DCLANG_ENABLE_FORMAT=OFF                           \
                -DCLANG_ENABLE_BOOTSTRAP=OFF                        \
                ../llvm
cmake --build . --target clang clang-repl --parallel $(nproc --all)

Note the 'llvm-project' directory location by executing

cd ../
export LLVM_DIR=$PWD
cd ../

You will need to define the following environment variables for the build of CppInterOp and cppyy (as they clear for a new session, it is recommended that you also add these to your .bashrc in linux, .bash_profile if on MacOS). On Linux and MacOS you define as follows

export CB_PYTHON_DIR="$PWD/cppyy-backend/python"
export CPPINTEROP_DIR="$CB_PYTHON_DIR/cppyy_backend"
export CPLUS_INCLUDE_PATH="${CPLUS_INCLUDE_PATH}:${LLVM_DIR}/llvm/include:${LLVM_DIR}/clang/include:${LLVM_DIR}/build/include:${LLVM_DIR}/build/tools/clang/include"

If on MacOS you will also need the following environment variable defined

export SDKROOT=`xcrun --show-sdk-path`

Now CppInterOp can be built. This can be done by executing

mkdir CppInterOp/build/
cd CppInterOp/build/
cmake -DBUILD_SHARED_LIBS=ON -DCPPINTEROP_USE_CLING=ON -DCPPINTEROP_USE_REPL=Off -DCling_DIR=$LLVM_DIR/build/tools/cling -DLLVM_DIR=$LLVM_DIR/build/lib/cmake/llvm -DClang_DIR=$LLVM_DIR/build/lib/cmake/clang -DCMAKE_INSTALL_PREFIX=$CPPINTEROP_DIR ..
cmake --build . --target install --parallel $(nproc --all)

To test the built CppInterOp execute the following command in the CppInterOP build folder on Linux and MacOS

cmake --build . --target check-cppinterop --parallel $(nproc --all)

Now go back to the top level directory in which your building CppInterOP

Now you are in a position to install cppyy following the instructions below.

Cling based CppInterOp Clone CppInterOp and cppyy-backend

First clone the CppInterOp repository, as this may contain patches that need to be applied to the subsequently cloned llvm-project repo

git clone --depth=1 https://github.com/compiler-research/CppInterOp.git

and clone cppyy-backend repository where we will be installing the CppInterOp library

git clone --depth=1 https://github.com/compiler-research/cppyy-backend.git

Build Cling and related dependencies

The Cling interpreter and depends on its own customised version of llvm-project, hosted under the root-project (see the git path below). Use the following build instructions to build

git clone https://github.com/root-project/cling.git
cd ./cling/
git checkout tags/v1.2
git apply -v ../CppInterOp/patches/llvm/cling1.2-LookupHelper.patch
cd ..
git clone --depth=1 -b cling-llvm18 https://github.com/root-project/llvm-project.git
mkdir llvm-project/build
cd llvm-project/build
cmake -DLLVM_ENABLE_PROJECTS=clang                                 \
                -DLLVM_EXTERNAL_PROJECTS=cling                     \
                -DLLVM_EXTERNAL_CLING_SOURCE_DIR=../../cling       \
                -DLLVM_TARGETS_TO_BUILD="host;NVPTX"               \
                -DCMAKE_BUILD_TYPE=Release                         \
                -DLLVM_ENABLE_ASSERTIONS=ON                        \
                -DCLANG_ENABLE_STATIC_ANALYZER=OFF                 \
                -DCLANG_ENABLE_ARCMT=OFF                           \
                -DCLANG_ENABLE_FORMAT=OFF                          \
                -DCLANG_ENABLE_BOOTSTRAP=OFF                       \
                ../llvm
cmake --build . --target clang --parallel $(nproc --all)
cmake --build . --target cling --parallel $(nproc --all)

Note the 'llvm-project' directory location by executing the following

cd ../
export LLVM_DIR=$PWD
cd ../

export CB_PYTHON_DIR="$PWD/cppyy-backend/python"
export CPPINTEROP_DIR="$CB_PYTHON_DIR/cppyy_backend"
export CLING_DIR="$(pwd)/cling"
export CLING_BUILD_DIR="$(pwd)/cling/build"
export CPLUS_INCLUDE_PATH="${CLING_DIR}/tools/cling/include:${CLING_BUILD_DIR}/include:${LLVM_DIR}/llvm/include:${LLVM_DIR}/clang/include:${LLVM_BUILD_DIR}/include:${LLVM_BUILD_DIR}/tools/clang/include:$PWD/include"

If on MacOS you will also need the following environment variable defined

export SDKROOT=`xcrun --show-sdk-path`

Now CppInterOp can be built. This can be done by executing

mkdir CppInterOp/build/
cd CppInterOp/build/
cmake -DBUILD_SHARED_LIBS=ON -DCPPINTEROP_USE_CLING=ON -DCPPINTEROP_USE_REPL=Off -DCling_DIR=$LLVM_DIR/build/tools/cling -DLLVM_DIR=$LLVM_DIR/build/lib/cmake/llvm -DClang_DIR=$LLVM_DIR/build/lib/cmake/clang -DCMAKE_INSTALL_PREFIX=$CPPINTEROP_DIR ..
cmake --build . --target install --parallel $(nproc --all)

To test the built CppInterOp execute the following command in the CppInterOP build folder on Linux and MacOS

cmake --build . --target check-cppinterop --parallel $(nproc --all)

Now go back to the top level directory in which your building CppInterOP

Now you are in a position to install cppyy following the instructions below.

Building and Install cppyy-backend

Cd into the cppyy-backend directory, build it and copy library files into python/cppyy-backend directory:

cd cppyy-backend
mkdir -p python/cppyy_backend/lib build 
cd build
cmake -DCppInterOp_DIR=$CPPINTEROP_DIR ..
cmake --build .

If on a linux system now execute the following command

cp libcppyy-backend.so ../python/cppyy_backend/lib/

and if on MacOS execute the following command

cp libcppyy-backend.dylib ../python/cppyy_backend/lib/

Note go back to the top level build directory

Create virtual environment and activate it:

python3 -m venv .venv
source .venv/bin/activate

git clone --depth=1 https://github.com/compiler-research/CPyCppyy.git
mkdir CPyCppyy/build
cd CPyCppyy/build
cmake ..
cmake --build .

Note down the path to the build directory as CPYCPPYY_DIR:

export CPYCPPYY_DIR=$PWD
cd ../..

Export the libcppyy path to python:

export PYTHONPATH=$PYTHONPATH:$CPYCPPYY_DIR:$CB_PYTHON_DIR

git clone --depth=1 https://github.com/compiler-research/cppyy.git
cd cppyy
python -m pip install --upgrade . --no-deps --no-build-isolation
cd ..

Each time you want to run cppyy you need to: Activate the virtual environment

source .venv/bin/activate

Now you can import cppyy in python

Follow the steps in Run cppyy. Change to the test directory, make the library files and run pytest:

cd cppyy/test
make all
python -m pip install pytest
python -m pytest -sv

Windows Clang-REPL based CppInterOp Clone CppInterOp and cppyy-backend

First clone the CppInterOp repository, as this may contain patches that need to be applied to the subsequently cloned llvm-project repo

git clone --depth=1 https://github.com/compiler-research/CppInterOp.git

and clone cppyy-backend repository where we will be installing the CppInterOp library

git clone --depth=1 https://github.com/compiler-research/cppyy-backend.git

Clone the 20.x release of the LLVM project repository.

git clone --depth=1 --branch release/20.x https://github.com/llvm/llvm-project.git
cd llvm-project

Clang-REPL is an interpreter that CppInterOp works alongside. Build Clang (and Clang-REPL along with it) by executing the following

$env:ncpus = $([Environment]::ProcessorCount)
mkdir build 
cd build 
cmake   -DLLVM_ENABLE_PROJECTS=clang                  `
        -DLLVM_TARGETS_TO_BUILD="host;NVPTX"          `
        -DCMAKE_BUILD_TYPE=Release                    `
        -DLLVM_ENABLE_ASSERTIONS=ON                   `
        -DCLANG_ENABLE_STATIC_ANALYZER=OFF            `
        -DCLANG_ENABLE_ARCMT=OFF                      `
        -DCLANG_ENABLE_FORMAT=OFF                     `
        -DCLANG_ENABLE_BOOTSTRAP=OFF                  `
        ..\llvm
cmake --build . --target clang clang-repl --parallel $env:ncpus

Note the 'llvm-project' directory location by executing the following

cd ..\
$env:LLVM_DIR= $PWD.Path
cd ..\

You will need to define the following environment variables for the build of CppInterOp (as they clear for a new session, it is recommended that you also add these to your profile.ps1). You define as follows (assumes you have defined $env:PWD_DIR= $PWD.Path )

$env:CB_PYTHON_DIR="$env:PWD_DIR\cppyy-backend\python"
$env:CPPINTEROP_DIR="$env:CB_PYTHON_DIR\cppyy_backend"
$env:CPLUS_INCLUDE_PATH="$env:CPLUS_INCLUDE_PATH;$env:LLVM_DIR\llvm\include;$env:LLVM_DIR\clang\include;$env:LLVM_DIR\build\include;$env:LLVM_DIR\build\tools\clang\include"

Now CppInterOp can be built. This can be done by executing

mkdir CppInterOp\build\
cd CppInterOp\build\
cmake -DLLVM_DIR=$env:LLVM_DIR\build\lib\cmake\llvm -DClang_DIR=$env:LLVM_DIR\build\lib\cmake\clang -DCMAKE_INSTALL_PREFIX=$env:CPPINTEROP_DIR ..
cmake --build . --target install --parallel $env:ncpus

To test the built CppInterOp execute the following command in the CppInterOP build folder and

cmake --build . --target check-cppinterop --parallel $env:ncpus

Cling based CppInterOp Clone CppInterOp and cppyy-backend

First clone the CppInterOp repository, as this may contain patches that need to be applied to the subsequently cloned llvm-project repo

git clone --depth=1 https://github.com/compiler-research/CppInterOp.git

and clone cppyy-backend repository where we will be installing the CppInterOp library

git clone --depth=1 https://github.com/compiler-research/cppyy-backend.git

Build Cling and related dependencies

The Cling interpreter and depends on its own customised version of llvm-project, hosted under the root-project (see the git path below). Use the following build instructions to build

git clone https://github.com/root-project/cling.git
cd .\cling\
git checkout tags/v1.2
git apply -v ..\CppInterOp\patches\llvm\cling1.2-LookupHelper.patch
cd ..
git clone --depth=1 -b cling-llvm18 https://github.com/root-project/llvm-project.git
$env:ncpus = $([Environment]::ProcessorCount)
$env:PWD_DIR= $PWD.Path
$env:CLING_DIR="$env:PWD_DIR\cling"
mkdir llvm-project\build
cd llvm-project\build
cmake   -DLLVM_ENABLE_PROJECTS=clang                  `
        -DLLVM_EXTERNAL_PROJECTS=cling                `
        -DLLVM_EXTERNAL_CLING_SOURCE_DIR="$env:CLING_DIR"   `
        -DLLVM_TARGETS_TO_BUILD="host;NVPTX"          `
        -DCMAKE_BUILD_TYPE=Release                    `
        -DLLVM_ENABLE_ASSERTIONS=ON                   `
        -DCLANG_ENABLE_STATIC_ANALYZER=OFF            `
        -DCLANG_ENABLE_ARCMT=OFF                      `
        -DCLANG_ENABLE_FORMAT=OFF                     `
        -DCLANG_ENABLE_BOOTSTRAP=OFF                  `
        ../llvm
cmake --build . --target clang --parallel $env:ncpus
cmake --build . --target cling --parallel $env:ncpus

Note the 'llvm-project' directory location by executing the following

cd ..\
$env:LLVM_DIR= $PWD.Path
cd ..\

$env:CB_PYTHON_DIR="$env:PWD_DIR\cppyy-backend\python"
$env:CPPINTEROP_DIR="$env:CB_PYTHON_DIR\cppyy_backend"
$env:CLING_DIR="$env:PWD_DIR\cling"
$env:CLING_BUILD_DIR="$env:PWD_DIR\cling\build"
$env:CPLUS_INCLUDE_PATH="$env:CLING_DIR\tools\cling\include;$env:CLING_BUILD_DIR\include;$env:LLVM_DIR\llvm\include;$env:LLVM_DIR\clang\include;$env:LLVM_BUILD_DIR\include;$env:LLVM_BUILD_DIR\tools\clang\include;$env:PWD_DIR\include;"

Now CppInterOp can be built. This can be done by executing

mkdir CppInterOp\build\
cd CppInterOp\build\
cmake -DCPPINTEROP_USE_CLING=ON -DCPPINTEROP_USE_REPL=Off -DCling_DIR=$env:LLVM_DIR\build\tools\cling -DLLVM_DIR=$env:LLVM_DIR\build\lib\cmake\llvm -DClang_DIR=$env:LLVM_DIR\build\lib\cmake\clang -DCMAKE_INSTALL_PREFIX=$env:CPPINTEROP_DIR ..
cmake --build . --target install --parallel $env:ncpus

To test the built CppInterOp execute the following command in the CppInterOP build folder and

cmake --build . --target check-cppinterop --parallel $env:ncpus

Further Reading: C++ Language Interoperability Layer

[^1]: Cling is an interpretive Compiler for C++. [^2]: Clang-REPL is an interactive C++ interpreter that enables incremental compilation. [^3]: LLVM is a Compiler Framework. It is a collection of modular compiler and toolchain technologies.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4