All technical blog posts written by people of the Stream HPC team.
It’s one of the age-old problems of software development: You’ve started a new project, set up fancy CI infrastructure, and everything works well. But as time goes on, you add more and more features to the project. Compile-times on your local checkout of the projects are mostly fine as you are used to incremental compilation, […]
HIP Compiler Acceleration Read More »
In our line of work, performing low-level performance optimization, the compiler is less of a language abstraction and more of a tool to directly interact with. Compilers are complex machines. Correctly converting C++-like code to assembly instructions is a gigantic challenge, producing optimized instructions even more so. It is therefore no surprise that the compiler
When to blame the compiler: an NVCC case study Read More »
If you haven’t used Lua before, it’s the go-to embedded scripting language for games like Factorio and World of Warcraft, and for applications like Neovim and OpenResty. LuaJIT, its just-in-time compiler, is widely praised for its speed, so it’s easy to assume your code is already running as fast as possible. In reality, you can
The LuaJIT NYI That Silently Poisoned an Unrelated Hot Loop Read More »
In the world of high-performance programming, true portable code has been a goal for a long time. Vulkan has been very successful at this, with Vulkan drivers being provided by every major GPU vendor and available for all common desktop and mobile operating systems. Platforms without first party support (e.g. Apple macOS/iOS) have compatibility layers
Image upscaling using convolutional neural networks in Vulkan Read More »
Anyone who has written a non-trivial GPU kernel has hit the same wall. You define a struct in C++ and pass it to a kernel. Six months later, somebody adds a member, forgets to update the matching layout on the device side, and a 200-line shader reads garbage. The compiler doesn’t help. The runtime doesn’t
Kernel development + C++26 reflection = 🧡 Read More »
In 2019 AMD announced the Radeon™ RX 5700 XT, a GPU that sported its brand-new at the time architecture named RDNA. It aimed to provide upgrades compared to the older GCN-based cards. Then one year later, AMD announced another GPU architecture — CDNA, with the release of the Radeon™ Instinct MI100. And in the current
RDNA and CDNA: similarities and differences Read More »
For the past decade, every C++ programmer who wanted to do real concurrent work has had the same conversation with themselves. std::async is a toy. std::thread is too low-level. std::future doesn’t compose. So you reach for TBB, or another third-party library, or a thread pool you wrote in 2017, or std::coroutine that you have to
Asynchronous and parallel programming in C++26 Read More »
Disclaimer: LLMs were used for proof-reading and grammar check. C++20 gave us coroutines. The machinery needed was included: co_yield, co_return, co_await but the standard library had no concrete coroutine types. You had to write your own promise type, your own iterator, your own bookkeeping. The complexity of this boilerplate was intimidating for most people. C++23
Lazy Ranges in C++23 with std::generator Read More »
At Stream HPC, we enjoy opportunities to connect with the HPC and accelerator community, exchange ideas, and learn from engineers and researchers working across the GPU ecosystem. Later this month, several members of our team will be attending GPU Day 2026 in Budapest, Hungary. Now in its 16th edition, GPU Day has become an established
Parallel primitives are the ubiquitous building blocks of GPU programming with CUDA and HIP, to make your life as a programmer easier. Primitives like scans, reductions, and sorts operate in parallel over large data inputs. The basic use case has input and output residing in device memory as an array of values. However, the libraries
Thinking with iterators in CUDA and HIP Read More »