C++ Installation and Configuration for Development Environments and Specialized Hardware

This article provides a detailed, step-by-step guide for installing and configuring C++ software tools and frameworks across different environments, including standard development setups, WebAssembly (Wasm) compilation, and GPU-accelerated execution on AMD ROCm platforms. The instructions are drawn from verified documentation, technical manuals, and firmware notes to ensure accuracy and reliability.

The installation and configuration of C++-based tools are critical for developers, system administrators, and enthusiasts who aim to leverage modern hardware and software capabilities. From compiling scientific libraries and interactive kernels to deploying machine learning frameworks, the process often involves multiple layers of dependencies, build systems, and environment-specific adjustments. The following sections outline the procedures for installing and testing C++ components in both traditional and specialized contexts.

Installation of xeus-cpp in a Conda Environment

The xeus-cpp project provides a C++ implementation of the Jupyter kernel, enabling interactive computing in Jupyter notebooks with C++ code. To ensure compatibility and avoid dependency conflicts, especially with the ZeroMQ library, it is recommended to use a micromamba or miniforge environment rather than a full Anaconda installation.

Prerequisites

• A working installation of micromamba
• A cloned copy of the xeus-cpp repository
• A fresh terminal session for environment setup

Step-by-Step Instructions

1. Clone the xeus-cpp Repository
   First, clone the xeus-cpp GitHub repository and navigate into the project directory:

   git clone --depth=1 https://github.com/compiler-research/xeus-cpp.git cd ./xeus-cpp

2. Create and Activate the Environment
   Create a new environment named xeus-cpp using the provided environment-dev.yml file:

   micromamba create -f environment-dev.yml micromamba activate xeus-cpp

3. Install JupyterLab
   Install JupyterLab from the Conda-Forge channel:

   micromamba install jupyterlab -c conda-forge

4. Build and Install the Kernel
   Create a build directory and configure the build with CMake. Replace $CONDA_PREFIX with a custom path if necessary:

   mkdir build && cd build cmake .. -D CMAKE_PREFIX_PATH=$CONDA_PREFIX -D CMAKE_INSTALL_PREFIX=$CONDA_PREFIX -D CMAKE_INSTALL_LIBDIR=lib make && make install

Notes

• Using a fresh environment prevents conflicts with system or globally installed libraries.
• The build process compiles the xeus-cpp kernel and installs it within the local environment.
• The CMake flags ensure that the build is configured for the correct prefix and library directories.

WebAssembly (Wasm) Build of xeus-cpp

In addition to traditional environments, xeus-cpp supports compilation for WebAssembly (Wasm), allowing the execution of C++ kernels in browser-based environments such as JupyterLab or interactive web notebooks.

Prerequisites for Wasm Build

• micromamba or conda
• Emscripten toolchain
• Cloned xeus-cpp repository

Step-by-Step Instructions

1. Clone the Repository and Create a Build Environment
   Clone the xeus-cpp repository and create a Wasm-specific environment:

   git clone --depth=1 https://github.com/compiler-research/xeus-cpp.git cd ./xeus-cpp micromamba create -f environment-wasm-build.yml -y micromamba activate xeus-cpp-wasm-build

2. Build the Wasm Kernel
   Create and activate a second environment for the Wasm host:

   micromamba create -f environment-wasm-host.yml --platform=emscripten-wasm32 mkdir build cd build export BUILD_TOOLS_PREFIX=$MAMBA_ROOT_PREFIX/envs/xeus-cpp-wasm-build export PREFIX=$MAMBA_ROOT_PREFIX/envs/xeus-cpp-wasm-host export SYSROOT_PATH=$BUILD_TOOLS_PREFIX/opt/emsdk/upstream/emscripten/cache/sysroot emcmake cmake \ -DCMAKE_BUILD_TYPE=Release \ -DCMAKE_INSTALL_PREFIX=$PREFIX \ -DXEUS_CPP_EMSCRIPTEN_WASM_BUILD=ON \ -DCMAKE_FIND_ROOT_PATH=$PREFIX \ -DSYSROOT_PATH=$SYSROOT_PATH \ .. emmake make install

3. Testing the Wasm Build
   To test the compiled kernel in a Node.js environment, navigate to the test directory and run:

   cd test node test_xeus_cpp.js

4. Optional: Headless Browser Testing
   For more comprehensive testing, run the tests in a headless browser such as Firefox or Chrome. This requires installing the browser binaries and running the tests via Emscripten's emrun tool.

   Example commands for macOS:

   wget "https://download.mozilla.org/?product=firefox-latest&os=osx&lang=en-US" -O Firefox-latest.dmg hdiutil attach Firefox-latest.dmg cp -r /Volumes/Firefox/Firefox.app $PWD hdiutil detach /Volumes/Firefox cd ./Firefox.app/Contents/MacOS/ export PATH="$PWD:$PATH" cd -

   After setting up the browser, run the test with:

   python $BUILD_PREFIX/bin/emrun.py --browser="firefox" --kill_exit --timeout 60 --browser-args="--headless" test_xeus_cpp.html

Notes

• The Wasm build is particularly useful for browser-based applications and interactive notebooks.
• Testing in a headless browser ensures compatibility and functionality without manual interaction.
• The build process leverages Emscripten, which requires additional configuration and environment variables.

Installation of llama.cpp on AMD ROCm Platforms

The llama.cpp framework is an open-source implementation of Large Language Models (LLMs) written in C/C++. It supports both CPU and GPU execution, including AMD ROCm platforms. The following instructions cover the installation and testing of llama.cpp using prebuilt Docker images and manual compilation.

Prerequisites

• A system with ROCm 6.4.0 installed
• CMake and HIP compiler
• ROCm-compatible AMD GPU

Installation via Docker

1. Pull a Prebuilt Docker Image
   Use a prebuilt Docker image to simplify the installation process. Replace <TAG> with the appropriate version:

   docker pull rocmlama/llama.cpp:<TAG>

   Example tag: llama.cpp-b5997_rocm6.4.0_ubuntu24.04

2. Run the Docker Container
   Start the container with the necessary environment variables:

   docker run -it --device=/dev/kfd --device=/dev/uio -e ROCM_VISIBLE_DEVICES=0 rocmlama/llama.cpp:<TAG>

3. Verify Installation
   Once inside the container, run the test suite to validate the installation:

   cd /workspace/llama.cpp ./build/bin/test-backend-ops

Manual Compilation

1. Clone the Repository
   git clone https://github.com/ROCm/llama.cpp cd llama.cpp

2. Set ROCm Architecture
   Define the target microarchitectures for compilation:

   export LLAMACPP_ROCM_ARCH=gfx803,gfx900,gfx906,gfx908,gfx90a,gfx942,gfx1010,gfx1030,gfx1032,gfx1100,gfx1101,gfx1102

3. Build and Install
   Compile the framework using CMake and HIP:

   HIPCXX="$(hipconfig -l)/clang" HIP_PATH="$(hipconfig -R)" \ cmake -S . -B build -DGGML_HIP=ON -DAMDGPU_TARGETS=$LLAMACPP_ROCM_ARCH \ -DCMAKE_BUILD_TYPE=Release -DLLAMA_CURL=ON \ && cmake --build build --config Release -j$(nproc)

4. Run a Test
   Execute a sample test to verify the installation:

   ./build/bin/test-backend-ops

Notes

• The Docker method is recommended for most users due to its ease of use and preconfigured dependencies.
• Manual compilation provides greater control over the build process and target architectures.
• A valid ROCm installation and an AMD GPU are required for GPU acceleration.

Installation of CPP Brake Components

While primarily focused on software, the provided documentation also includes a brief on the installation of CPP brake components for automotive applications. These instructions are relevant for DIY automotive enthusiasts and professional mechanics.

Prerequisites

• CPP brake booster and master cylinder kit
• Basic hand tools (wrenches, pliers, screwdrivers)
• Vehicle with a compatible firewall and brake pedal setup

Step-by-Step Instructions

1. Prepare the Vehicle
   Ensure the firewall and shock towers are clear of debris and obstructions. The CPP kit includes a 9-inch booster designed for direct fitment.

2. Install the Booster Assembly
   Slide the brake booster into place behind the firewall. Install the new gasket, seal, and pushrod. Remove the three nuts and pin from the clevis before installation.

3. Align the Clevis and Pedal
   Ensure the clevis is aligned with the brake pedal. Start the studs through the firewall and confirm the clevis is in place.

4. Secure the Clevis
   From under the dash, attach the clevis to the brake pedal using the supplied pin. Tighten the three nuts using an extension and swivel tool.

5. Plumbing the System
   Install the block-off plug on the proportioning valve and attach the hard lines. One line connects to the driver-side fender, while two lines go to the passenger side.

Notes

• The installation is designed for simplicity and direct fitment.
• Ensure all components are correctly aligned before tightening.
• Test the system before driving to verify proper operation.

Conclusion

This guide outlines the installation and configuration of C++-based tools and hardware components across multiple environments, including traditional development, WebAssembly compilation, and GPU acceleration via AMD ROCm. The detailed instructions emphasize best practices for dependency management, environment setup, and testing procedures. Whether for scientific computing, interactive kernels, or automotive applications, these steps provide a reliable and structured approach to deployment.

By following the outlined procedures, users can ensure compatibility, performance, and stability in their C++ environments, leveraging both open-source and proprietary tools to meet their technical requirements.

Sources

1. xeus-cpp Installation and Usage Documentation
2. llama.cpp Installation on ROCm
3. Classic Performance Products Brake Installation Guide
4. CPP Pipe Technical Documents