Raymond P. Burkholder - Things I Do - C++

JUCE: Audio Framework

nospam@example.com (Raymond P. Burkholder) — Sat, 11 Apr 2026 03:06:58 +0000

Note to self: come back to this and redo some non-functional audio logic located in some code which needs to be uprooted and re-juiced.

JUCE - open source, cross-platform, software development framework provided as C++ source code, that can be used to create standalone software on Windows, macOS, Linux, iOS and Android, as well as VST, VST3, AU, AUv3, AAX and LV2 plug-ins.

Installing LibTorch with Cuda on NVIDIA GeForce RTX 4070

nospam@example.com (Raymond P. Burkholder) — Fri, 09 May 2025 03:09:46 +0000

For trying out some LSTM Machine Learning algorithms with my TradeFrame Algorithmic Trading Library, I wanted to install LibTorch with NVidia/Cuda support for hardware accelerating learning.

Do not install the nvidia-driver yet. It is part of the cuda deployment package. Only install headers, which are necessary for building kernal modules.

$ sudo apt install linux-headers-$(uname -r)

I used Installing C++ Distributions of PyTorch as a starting point. However, their example is CPU based. My desire is for a Cuda based installation. This meant going to the CUDA Zone and start the Download process. My configuration options were: Linux, x86_64, Debian, 12, deb (local).

Using the "deb (local)" with a complete file seemed to be the only way to ensure all components were available.

The steps, as of this writing, were:

wget https://developer.download.nvidia.com/compute/cuda/12.9.0/local_installers/cuda-repo-debian12-12-9-local_12.9.0-575.51.03-1_amd64.deb
sudo dpkg -i cuda-repo-debian12-12-9-local_12.9.0-575.51.03-1_amd64.deb
sudo cp /var/cuda-repo-debian12-12-9-local/cuda-*-keyring.gpg /usr/share/keyrings/
sudo apt-get update
sudo apt-get -y install cuda-toolkit-12-9

Install the open version of the nvidia drivers:

sudo apt-get install -y nvidia-open

See if the nouveau driver is installed.

$ lsmod |grep nouveau

If so, then run these commands to enable the nvidia driver and to blacklist the nouveau driver and reboot:

sudo mv /etc/modprobe.d/nvidia.conf.dpkg-new  /etc/modprobe.d/nvidia.conf
sudo update-initramfs -u

There is also the NVIDIA CUDA Installation Guide for Linux for further information.

The following changes are required for a successful compile of the example application below:

$ diff math_functions.h /etc/alternatives/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h
2556c2556
< extern __DEVICE_FUNCTIONS_DECL__ __device_builtin__ double                 sinpi(double x);
---
> extern __DEVICE_FUNCTIONS_DECL__ __device_builtin__ double                 sinpi(double x) noexcept (true);
2579c2579
< extern __DEVICE_FUNCTIONS_DECL__ __device_builtin__ float                  sinpif(float x);
---
> extern __DEVICE_FUNCTIONS_DECL__ __device_builtin__ float                  sinpif(float x) noexcept (true);
2601c2601
< extern __DEVICE_FUNCTIONS_DECL__ __device_builtin__ double                 cospi(double x);
---
> extern __DEVICE_FUNCTIONS_DECL__ __device_builtin__ double                 cospi(double x) noexcept (true);
2623c2623
< extern __DEVICE_FUNCTIONS_DECL__ __device_builtin__ float                  cospif(float x);
---
> extern __DEVICE_FUNCTIONS_DECL__ __device_builtin__ float                  cospif(float x) noexcept (true);

use this file to fix the above:

$ cat cuda_fix.sh
#!/bin/sh
header_file=/etc/alternatives/cuda/bin/../targets/x86_64-linux/include/crt/math_functions.h
sudo sed -i 's/sinpi(double x);/sinpi(double x) noexcept (true);/' $header_file
sudo sed -i 's/sinpif(float x);/sinpif(float x) noexcept (true);/' $header_file
sudo sed -i 's/cospi(double x);/cospi(double x) noexcept (true);/' $header_file
sudo sed -i 's/cospif(float x);/cospif(float x) noexcept (true);/' $header_file

The PyTorch LibTorch library can be downloaded from PyTorch Start Locally. Choose the C++/Java option with Cuda 12.8 (as of this writing). An appropriate link is presented. Download and expand the file into a development directory. LibTorch doesn't have at this moment a build for Cuda 12.9, but is referenced as 12.8.

The most recent can be found at https://download.pytorch.org/libtorch/nightly/cu128/libtorch-shared-with-deps-latest.zip.

It is probably advised to NOT use the Debian package, as it may be out of date: pytorch-cuda.

Expand the libtorch package and deploy to /usr/local/share/libtorch.

To test out the installation, I then created a subdirectory containing a couple of files. The first is the test code example-app.cpp:

#include <torch/torch.h>
#include <iostream>

int main() {
  torch::Tensor tensor = torch::rand({2, 3});
  std::cout << tensor << std::endl;
}

The second file is the CMakeLists.txt file. This is my version:

cmake_minimum_required(VERSION 3.18 FATAL_ERROR)

cmake_policy(SET CMP0104 NEW)
cmake_policy(SET CMP0105 NEW)
project(example-app)

find_package(Torch REQUIRED)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${TORCH_CXX_FLAGS}")
set(CMAKE_CUDA_STANDARD 17)

add_executable(example-app example-app.cpp)
target_link_libraries(example-app "${TORCH_LIBRARIES}")
set_property(TARGET example-app PROPERTY CXX_STANDARD 17)

Then to build the example:

mkdir build
cmake \
  -DCMAKE_PREFIX_PATH=/usr/local/share/libtorch \
  -DCMAKE_CUDA_ARCHITECTURES=native \
  -DCMAKE_BUILD_TYPE=DEBUG \
  -DCMAKE_CUDA_COMPILER=/etc/alternatives/cuda/bin/nvcc \
  -Dnvtx3_dir=/usr/local/cuda/targets/x86_64-linux/include/nvtx3  \
  ..
make
./example-app

Notes:

PREFIX_PATH points to the directory of your expanded libtorch download
CMAKE_CUDA_ARCHITECTURES provides a 'native' cuda solution, the build process will determine the specific gpu for which to build
CMAKE_BUILD_TYPE can be DEBUG or RELEASE
CMAKE_CUDA_COMPILER needs to be set, by using /etc/alternatives, these are softlinks to the version you desire (as were installed by the cuda installation)
nvtx3_dir is required, as the current libtorch library seems to still refer to nvtx and not nvtx3

If you get output along the lines of:

-- Automatic GPU detection failed. Building for common architectures.
-- Autodetected CUDA architecture(s): 5.0;8.0;8.6;8.9;9.0;9.0a;10.0;10.0a;10.1a;12.0;12.0a

My system has two RTX 4070 cards, and can be verified with (an extract is shown with important parts, noticing that the nvidia driver is properly shown):

$ sudo lshw -c video
  *-display
    product: Arrow Lake-S [Intel Graphics]
    configuration: depth=32 driver=i915 latency=0 mode=3840x2160 resolution=3840,2160 visual=truecolor xres=3840 yres=2160
  *-display
    product: AD103 [GeForce RTX 4070]
    configuration: driver=nvidia latency=0
  *-display
    product: AD103 [GeForce RTX 4070]
    configuration: driver=nvidia latency=0

Therefore, the output of my cmake process will include gpu specific selections:

-- Autodetected CUDA architecture(s):  8.9 8.9
-- Added CUDA NVCC flags for: -gencode;arch=compute_89,code=sm_89

And running the generated binary results in valid output:

$ ./example-app
0.7141  0.9744  0.3179
0.7794  0.9281  0.7529
[ CPUFloatType{2,3} ]

Continue reading "Installing LibTorch with Cuda on NVIDIA GeForce RTX 4070"

CMake

nospam@example.com (Raymond P. Burkholder) — Sat, 14 Dec 2024 17:52:38 +0000

CMake: the Good, the Bad, the Weird - ... strongly recommend for any developers who are learning or struggling with CMake to purchase Professional CMake -- I have found it very helpful in explaining things where most other resources haven't, and it is consistently updated with new major versions of CMake.

C++ Header File Statistics

nospam@example.com (Raymond P. Burkholder) — Sun, 04 Feb 2024 14:02:56 +0000

From #include <rules>, via hacker news, two compile time options to consider:

use the preprocessor output (cl /E, gcc -E)
use the include output (cl /showIncludes, gcc -M), gather the codebase statistics (average size after preprocessing, most included header files, header files with largest payload, etc.)

I've been doing this backwards, but I don't understand why though:

The header file named after the source should be included first (to catch errors in the header)

Boehm Garbage Collection, Cords String Handling

nospam@example.com (Raymond P. Burkholder) — Sun, 21 Jan 2024 16:39:38 +0000

HackerNews had an article about Boehm-Demers-Weiser conservative C/C++ Garbage Collector which leads to A garbage collector for C and C++.

It can be used in garbage collection mode or leak detection mode.

The garbage collector distribution includes a C string (cord) package that provides for fast concatenation and substring operations on long strings. A simple curses- and win32-based editor that represents the entire file as a cord is included as a sample application. From Wikipedia:

Boehm GC is also distributed with a C string handling library called cords. This is similar to ropes in C++ (trees of constant small arrays), but instead of using reference counting for proper deallocation, it relies on garbage collection to free objects. Cords are good at handling very large texts, modifications to them in the middle, slicing, concatenating, and keeping history of changes (undo/redo functionality).

Code can be found at github - The Boehm-Demers-Weiser conservative C/C++ Garbage Collector (bdwgc, also known as bdw-gc, boehm-gc, libgc)

Parallelism and Concurrency

nospam@example.com (Raymond P. Burkholder) — Wed, 10 Jan 2024 03:47:38 +0000

HPX -- An open source C++ Standard Library for Parallelism and Concurrency

To achieve scalability with today's heterogeneous HPC resources, we need a dramatic shift in our thinking; MPI+X is not enough. Asynchronous Many Task (AMT) runtime systems break down the global barriers imposed by the Bulk Synchronous Programming model. HPX is an open-source, C++ Standards compliant AMT runtime system that is developed by a diverse international community of collaborators called The Ste||ar Group. HPX provides features which allow application developers to naturally use key design patterns, such as overlapping communication and computation, decentralizing of control flow, oversubscribing execution resources and sending work to data instead of data to work. The Ste||ar Group comprises physicists, engineers, and computer scientists; men and women from many different institutions and affiliations, and over a dozen different countries. We are committed to advancing the development of scalable parallel applications by providing a platform for collaborating and exchanging ideas. In this paper, we give a detailed description of the features HPX provides and how they help achieve scalability and programmability, a list of applications of HPX including two large NSF funded collaborations (STORM, for storm surge forecasting; and STAR (OctoTiger) an astro-physics project which runs at 96.8% parallel efficiency on 643,280 cores), and we end with a description of how HPX and the Ste||ar Group fit into the open source community.

TimeGraphs: Graph-based Temporal Reasoning

Many real-world systems exhibit temporal, dynamic behaviors, which are captured as time series of complex agent interactions. To perform temporal reasoning, current methods primarily encode temporal dynamics through simple sequence-based models. However, in general these models fail to efficiently capture the full spectrum of rich dynamics in the input, since the dynamics is not uniformly distributed. In particular, relevant information might be harder to extract and computing power is wasted for processing all individual timesteps, even if they contain no significant changes or no new information. Here we propose TimeGraphs, a novel approach that characterizes dynamic interactions as a hierarchical temporal graph, diverging from traditional sequential representations. Our approach models the interactions using a compact graph-based representation, enabling adaptive reasoning across diverse time scales. Adopting a self-supervised method, TimeGraphs constructs a multi-level event hierarchy from a temporal input, which is then used to efficiently reason about the unevenly distributed dynamics. This construction process is scalable and incremental to accommodate streaming data. We evaluate TimeGraphs on multiple datasets with complex, dynamic agent interactions, including a football simulator, the Resistance game, and the MOMA human activity dataset. The results demonstrate both robustness and efficiency of TimeGraphs on a range of temporal reasoning tasks. Our approach obtains state-of-the-art performance and leads to a performance increase of up to 12.2% on event prediction and recognition tasks over current approaches. Our experiments further demonstrate a wide array of capabilities including zero-shot generalization, robustness in case of data sparsity, and adaptability to streaming data flow.

How to do a dynamic parser in X3?

nospam@example.com (Raymond P. Burkholder) — Sun, 24 Sep 2023 00:26:51 +0000

how to do a dynamic parser in X3?

The presentation went well, but as always with a large surface area library like Spirit it went on for too long IMO (2 hrs). This was similar to what happened when I presented Spirit 2.x almost 10 yrs ago. If I were to present on this again, I would split the topic into two talks:

A background on recursive variant datatypes and visitor pattern and dipping into the Fusion library for adapting arbitrary application structures to Fusion tuples.
Spirit X3 parsing w/annotations and error handling.

I try to present from real code in the IDE as much as possible so that we're looking at real code. I almost always write my own examples with the library I'm presenting and put them on github. The exception is when the library comes with an example that is everything I want to talk about .
I cribbed quite a bit from the spirit x3 fun example presented by Michael Caisse a few years back, but I did extend the AST to handle imaginary numbers.

Stop VSCode from adding headers

nospam@example.com (Raymond P. Burkholder) — Sun, 11 Jun 2023 18:04:01 +0000

Visual Studio Code, by default, when using the clangd language server, will automatically insert headers files for types which may have already been declared.

To disable this, go into the configuration options for clangd, and in 'clangd:arguments' add:

--header-insertion=never

Source: Stop VSCode from adding redundant headers

GCC Optimization for Native Architecture

nospam@example.com (Raymond P. Burkholder) — Sun, 27 Mar 2022 17:48:33 +0000

When using Cern's ROOT Data Analysis Framework, there are notes about possible compile time enhancements. It is best to take a look on which cpu variant the compiler will generate code, and for which target cpu the code will run. They need to be compatible.

AVX-512 is an interesting Wikipedia page describing the various cpu variant incarnations and their specialized instruction subsets.

Here are a few command line examples for examining what the gcc compiler sees as being available.

$ gcc -march=native -Q --help=target | grep march
  -march=                               skylake
  Known valid arguments for -march= option:

$ echo | gcc -dM -E - -march=native
  ... large quantity of flags ...

gcc x86 cpu options cmake command:

add_definitions(-march=native)

Even though this optimizes instruction use, it has to be used carefully. It will probably cause side effects with compiling code on one version of cpu and when copying the executables to a different machine, with possibly a different cpu variant.

Reference: How to see which flags -march=native will activate?

C++ References

nospam@example.com (Raymond P. Burkholder) — Sun, 20 Mar 2022 12:29:16 +0000

Tutorial: When to Write Which Special Member - "When explaining someone the rules behind the special member functions and when you need to write which one, there is this diagram that is always brought up. I don’t think the diagram is particularly useful for that, however."

Tutorial: Managing Compiler Warnings with CMake - " But how do you manage the very compiler-specific flags in CMake? How do you prevent your header files from leaking warnings into other projects?"

Papers 2022/02/05

nospam@example.com (Raymond P. Burkholder) — Sat, 05 Feb 2022 22:44:45 +0000

Pipeflow: An Efficient Task-Parallel Pipeline Programming Framework using Modern C++

Pipeline is a fundamental parallel programming pattern. Mainstream pipeline programming frameworks count on data abstractions to perform pipeline scheduling. This design is convenient for data-centric pipeline applications but inefficient for algorithms that only exploit task parallelism in pipeline. As a result, we introduce a new task-parallel pipeline programming framework called Pipeflow. Pipeflow does not design yet another data abstraction but focuses on the pipeline scheduling itself, enabling more efficient implementation of task-parallel pipeline algorithms than existing frameworks. We have evaluated Pipeflow on both micro-benchmarks and real-world applications. As an example, Pipeflow outperforms oneTBB 24% and 10% faster in a VLSI placement and a timing analysis workloads that adopt pipeline parallelism to speed up runtimes, respectively.

3D Modelling Software - C++ API

nospam@example.com (Raymond P. Burkholder) — Sat, 16 Jan 2021 20:30:24 +0000

Since none of this is registered in github, here is my alternate mechanism for 'staring' these items:

FreeCAD - open-source parametric 3D modeler made primarily to design real-life objects of any size. Parametric modeling allows you to easily modify your design by going back into your model history and changing its parameters. You get modern Finite Element Analysis (FEA) tools, experimental CFD, dedicated BIM, Geodata or CAM/CNC workbenches, a robot simulation module that allows you to study robot movements and many more features.
cppyy: Automatic Python-C++ bindings - an automatic, run-time, Python-C++ bindings generator, for calling C++ from Python and Python from C++
Open CASCADE Technology, The Open Source 3D Modeling Libraries - is a software development kit (SDK) intended for development of applications dealing with 3D CAD data or requiring industrial 3D capabilities. It includes a set of C++ class libraries providing services for 3D surface and solid modeling, CAD data exchange, and visualization. tutorial
OpenStudio is a cross-platform (Windows, Mac, and Linux) collection of software tools to support whole building energy modeling using EnergyPlus and advanced daylight analysis using Radiance.
Topologic is a software development kit and plug-in that enables logical, hierarchical and topological representation of spaces and entities

C++ Currency Library

nospam@example.com (Raymond P. Burkholder) — Sat, 09 May 2020 23:48:35 +0000

Some C++ libraries I've encountered for managing currency manipulation:

vpiotr / decimal_for_cpp - this is the one I use for my currency work, is header based, succinct, and easy to use.
I was wondering if boost.multiprecision could be used, and came up with mariusbancila / moneycpp - a bit too much for me as it also handles currency codes. There is a a blog entry: moneycpp – a C++ library for handling monetary values.
General Decimal Arithmetic goes into some detail about the related IEEE 754 standard, as well as a link to a C language implementation.

Visual Studio Code with CMake and Clangd

nospam@example.com (Raymond P. Burkholder) — Sun, 22 Dec 2019 03:40:30 +0000

Continuing on in the search for a responsive IDE for building large C++ codesets with CMake, the next stop is Visual Studio Code.

The initial install supplies a basic IDE editing environment.

Usability occurs when extensions are loaded. I have the following installed (versions are as of this writing):

C/C++ for Visual Studio Code, v0.26, by Microsoft <== some sites say to disable this, but it is required by the debug function
CMake, v0.0.17, by twxs, which provides CMake language support
CMake Tools, v1.2.3, by Microsoft, which provides the build capability
vscode-clangd, v0.0.19, is the clang language server, which provides code completion and symbol tables

Prior to installation of the extensions, on Debian, I installed the following packages first (in addition to the standard compilers):

cmake
clangd
clangd-9

reddit - PROTIP: Use clangd instead of the official C/C++ extension suggests adding the following to .vscode/settings.json:

"C_Cpp.autocomplete": "Disabled",
"C_Cpp.formatting": "Disabled",
"C_Cpp.errorSquiggles": "Disabled",
"C_Cpp.intelliSenseEngine": "Disabled",

In addition, I have a more recent version of clangd, so in .vscode/settings.json, I also have:

"clangd.path": "/usr/lib/llvm-9/bin/clangd",

My over all file looks like:

{
  "clangd.path": "/usr/lib/llvm-9/bin/clangd",
  "C_Cpp.autocomplete": "Disabled",
  "C_Cpp.formatting": "Disabled",
  "C_Cpp.errorSquiggles": "Disabled",
  "C_Cpp.intelliSenseEngine": "Disabled",
  "C_Cpp.default.intelliSenseMode": "clang-x64",
  "editor.tabSize": 2
}

In the root directory of the project, a link is required (the setting "compileCommands" in .vscode/c_cpp_properties.json does not appear to be used by the clangd module) :

ln -s build/compile_commands.json .

2023/11/05 - Or add the following to .vscode/settings.json (which causes the file to be created and referenced directly in the basic workspace directory):

"cmake.copyCompileCommands": "${workspaceFolder}/compile_commands.json"

As a note, if compile_commands.json is not provided, then the following flag needs to be passed to CMake (seems to be defaulted "on" in current Visual Studio Code):

-DCMAKE_EXPORT_COMPILE_COMMANDS=1

Documentation for clangd is found at Getting started with clangd.

CMake

nospam@example.com (Raymond P. Burkholder) — Fri, 05 Apr 2019 03:52:25 +0000

As a continuation of my other article incorporating CMake as a makefile generator, here are some references I used for getting a handle on how to build a set of CMakeLists.txt files to manage a project containing a library shared by two applications.

Tutorial: Managing Compiler Warnings with CMake - But how do you manage the very compiler-specific flags in CMake? How do you prevent your header files from leaking warnings into other projects?
cmake.org tutorial
Reference Guide - direct from cmake.org
CMake Community Wiki
wxWiki - using CMake to include wxWidgets in projects - see below for sample
stack overflow - Questions tagged [cmake] - the popular entries
stack overflow - Multiple sub-projects depending on the same library - primary source for skeleton entries for a project with inter-dependent apps and libraries.
stack overflow - CMake: Static library with multiple projects - Normally, when CMake projects have to cooperate, it's beneficial to make them part of the same buildsystem using add_subdirectory(). That way, CMake can track dependency between their targets, automatically resolve references to logical target names etc.
Typical Linux Project using CMake - goes into detail for a project with libraries and applications, including external dependencis
CMake Dependencies Done Right - mechanisms to evolve a CMake file - depend on defining a proper dependency tree for all libraries and executables
stack overflow - CMake: Project structure with unit tests
Basic CMake C++ project structure - includes an example of ExternalProject_Add - also with style notes in one of the answers
stack overflow - CMake Setting up Release and Debug version and Flags 'cmake -DCMAKE_BUILD_TYPE=Release .. ', 'cmake -DCMAKE_BUILD_TYPE=Debug .. '
How to configure a C/C++ project with Eclipse and CMake - manual mechanism when not using the wizard from the gui - talks about debug/release versions - something which isn't intuitively obvious when using the gui wizard for importing a CMake progject
It's Time To Do CMake Right - Pablo Arias - Build Requirements vs Usage Requirements - defines public, private, interface plus additional concepts
Mirko Kiefer's Blog - CMake by Example - a few twists on the simple CMake files with a focus on the 'install' concept
CMake Examples on github. There is something to be learned from each example [added 2019/0917]
CMake – Properties and Options - conditionals - which shares an example with CMAKE compile options
dendisuhubdy / libtorch_examples - has an example of how to use custom commands [could be used with my libs-build]
2020/02/25 CMake is not a build system - brief walk through of key features.
2021/05/23 Effective Modern CMake - many 'thou shalts', but few examples on what it means, other than that, effective starting point on the research journey

wxWidgets inclusion with CMake

project(myGreatProject)
cmake_minimum_required(VERSION 2.
aux_source_directory(. SRC_LIST)

set(wxWidgets_CONFIGURATION mswu)
find_package(wxWidgets COMPONENTS core base REQUIRED)
include(${wxWidgets_USE_FILE})

add_executable(${PROJECT_NAME} ${SRC_LIST})
target_link_libraries(${PROJECT_NAME} ${wxWidgets_LIBRARIES})

Random note:

${CMAKE_SOURCE_DIR}, ${CMAKE_BINARY_DIR}

Generator for ninja:

cmake -G Ninja.