Working at @UniHeidelberg. I do AdaptiveCpp and HPC. Making things go fast! @illuhad.bsky.social
Heidelberg, Germany
Joined November 2018
- Tweets984
- Following161
- Followers466
- Likes903
#AdaptiveCpp 25.10 released! Introducing a deployment model (compile once, ship to NVIDIA/AMD/Intel GPUs and CPUs), performance improvements and more! github.com/AdaptiveCpp/Adapt…
#AdaptiveCpp 25.02 released! Introducing AdaptiveCpp portable CUDA (PCUDA):direct support for the CUDA and HIP languages in AdaptiveCpp's compiler. Compile CUDA code, obtain single binary that runs on CPU, Intel GPU, NVIDIA GPU, AMD GPU. github.com/AdaptiveCpp/Adapt…
Aksel Alpay retweeted
AdaptiveCpp 24.10 Delivers More Performance Optimizations
phoronix.com/news/AdaptiveCp…
#AdaptiveCpp 24.10.0 has just been released! Even more performance and more features, including data parallel SYCL algorithms, group algorithms for the generic JIT compilre, JIT reflection and more! github.com/AdaptiveCpp/Adapt…
#AdaptiveCpp performed well here - even though it had two performance-critical disadvantages: 1) it was not accounted for that DPC++ uses -ffast-math by default while AdaptiveCpp does not and 2) not using the AdaptiveCpp generic JIT compiler and its additional optimizations.
Performance portability via C++ PSTL, SYCL, OpenMP, and HIP: the Gaia AVU-GSR case study
#HIP #SYCL #OpenMP #CUDA #PerformancePortability #HPC #Astrophysics #Package
hgpu.org/?p=29555
While there are limitations, the more I work on C++ standard parallelism offloading, the more I am amazed by what *can* be done. Here, we demonstrate nbody tree algorithms on GPUs. Just standard C++. And AdaptiveCpp runs the same binary on Intel/NVIDIA/AMD hardware ;)
Key moments from our IA^3 talk on Efficient Tree-based Parallel Algorithms for N-Body Simulations Using C++ Standard Parallelism.
where we build trees on CPUs and GPUs using a starvation-free algorithm with the *same* code in C++.
buff.ly/3ZeCxir
#SC24
Photo: G. Brito.
Aksel Alpay retweeted
Key moments from our IA^3 talk on Efficient Tree-based Parallel Algorithms for N-Body Simulations Using C++ Standard Parallelism.
where we build trees on CPUs and GPUs using a starvation-free algorithm with the *same* code in C++.
buff.ly/3ZeCxir
#SC24
Photo: G. Brito.
In other news, #AdaptiveCpp is now the most popular @SYCLstd implementation according to github stars, ahead of DPC++ and going strong!
Aksel Alpay retweeted
AdaptiveCpp 24.06 Released As "The Fastest Heterogeneous C++ Compiler" - Beats CUDA
Impressive performance!
phoronix.com/news/AdaptiveCp…
Aksel Alpay retweeted
#AdaptiveCpp 24.06 released! A new performance king is in town. github.com/AdaptiveCpp/Adapt…
Aksel Alpay retweeted
C++ Weekly - Ep 435 - Easy GPU Programming With AdaptiveCpp (68x Faster!)
youtube.com/watch?v=ImM7f5IQ…
#cpp
#cplusplus
Great episode on #AdaptiveCpp on C++ weekly. Cool to see how simply recomiling with AdaptiveCpp improved perf by 68x thanks to its C++ standard algorithms offloading support : youtube.com/watch?v=ImM7f5IQ…
If you use SYCL buffers you: 1. use an API that introduces overheads 2. prevents you from future optimizations because it is incompatible with the more efficient USM model 3. are you using a verbose API. Conclusion: Just use USM.
It's surprising how often the buffer-accessor model is still used in 2024 by SYCL beginners. IMO we should remove it from the "hello world" example in the spec and maybe also only introduce it way, way later in training materials. No production app uses it, and IMO nobody should.
Aksel Alpay retweeted
Check out this blog and demo by @CERN introducing the open-source #AdaptivePerf and how we'll use it to profile our use cases for the #SYCLOPS Project!
syclops.org/updates/2024/06/…
#SYCL
roc-stdpar in ROCm 6.1 is broken unless you have HMM. Even better workaround than what AMD suggested: Just use AdaptiveCpp. Unlike roc-stdpar, it can also deliver performance without the elusive XNACK hardware feature (if you don't know what it is, chances are you don't have it).
Want to know why and how AdaptiveCpp outperforms vendor compilers (nvc++, roc-stdpar, icpx) for C++ parallel STL offload? Read my brand-new @IWOCL paper: dl.acm.org/doi/10.1145/36481…
Aksel Alpay retweeted
Next up, @illuhad from @UniHeidelberg speaks about the new support for @isocpp standard parallelism based on @SYCLstd in AdaptiveCpp, and provides a smooth path from C++ to SYCL when you need more control whilst maintaining a portable application.
