Kompute – Vulkan Alternative to CUDA

Vulkan has some advantages to OpenCL. You gain lower level control over memory allocation and resource synchronization. Rocm has an infamous synchronization pessimization which doesn't exist for Vulkan. You can even explicitly allocate Vulkan resources at specific memory addresses, which means Vulkan can easily be used for embedded devices.

But some of the caveats for compute applications are currently:

- No bfloat16 in shaders

- No shader work graphs (GPU-driven shader control flow)

- No inline PTX (inline GCN/RDNA/GEN is available)

These may or may not be important to you. Vulkan recently gained an ability to seamlessly dispatch CUDA kernels if you need these in some places, but there aren't currently similar Vulkan extensions for HIP.

This is _not_ an alternative to CUDA nor to OpenCL. It has some high-level and opinionated API [1], which covers a part (rather small part) of the API of each of those.

It may, _in principle_, have been developed - with much more work than has gone into it - into such an alternative; but I am actually not sure of that since I have poor command of Vulcan. I got suspicious being someone who maintains C++ API wrappers for CUDA myself [2], and know that just doing that is a lot more code and a lot more work.

[1] - I assume it is opinionated to cater to CNN simulation for large language models, and basically not much more.

[2] - https://github.com/eyalroz/cuda-api-wrappers/

This looks great - I've been looking for a sustainable, cross-platform-and-vendor GPU compute solution, and the alternatives are not really great. CUDA is nvidia only, Metal is apple only, etc etc. OpenCL has been the closest match but it seems like it's on the way out.

Does anyone have real world experience using Vulkan compute shaders versus, say, OpenCL? Does Kompute make things as straightforward as it seems?

Alternatives can only become one, if they support the same set of C, C++, Fortran, and PTX compiler backends, with similar level of IDE integration, grapical GPGPU debugging, and frameworks.

Until then they are wannabe alternatives, for a subset of use cases, with lesser tooling.

It always feels like those proposing CUDA alternatives don't understand what they are trying to replace, and that is already the first error.

A key component of CUDA is that the kernels are written in C/C++ and not some shader language you would only be familiar with if you were into graphics.

Anyone have a comparison to something like wgsl's compute shader mode over stuff like wgpu? I've never seriously written in either.

Pytorch alreadh has Vulkan support -- and Kompute does not support pytorch yet. That's is going to show adaptation of this project.

Kompute author here - thank you very much for sharing our work!

If you are interested to learn more, do join the community through our discord here: https://discord.gg/MaH5Jv5zwv

For some background, this project started after seeing various renowned machine learning frameworks like Pytorch and Tensorflow integrating Vulkan as a backend. The Vulkan SDK offers a great low level interface that enables for highly specialized optimizations - however it comes at a cost of highly verbose code which requires 800-2000 lines of code to even begin writing application code. This has resulted in each of these projects having to implement the same baseline to abstract the non-compute related features of the Vulkan SDK.

This large amount of non-standardised boiler-plate can result in limited knowledge transfer, higher chance of unique framework implementation bugs being introduced, etc. We are aiming to address this with Kompute. As of today, we are now part of the Linux Foundation, and slowly contributing to the cross-vendor GPGPU revolution.

Some of the key features / highlights of Kompute:

* C++ SDK with Flexible Python Package * BYOV: Bring-your-own-Vulkan design to play nice with existing Vulkan applications * Asynchronous & parallel processing support through GPU family queues * Explicit relationships for GPU and host memory ownership and memory management: https://kompute.cc/overview/memory-management.html * Robust codebase with 90% unit test code coverage: https://kompute.cc/codecov/ * Mobile enabled via Android NDK across several architectures

Relevant blog posts:

Machine Learning: https://towardsdatascience.com/machine-learning-and-data-pro...

Mobile development: https://towardsdatascience.com/gpu-accelerated-machine-learn...

Game development (we need to update to Godot4): https://towardsdatascience.com/supercharging-game-developmen...

Can't we make a chip that only does one thing: multiply and add a lot of 32x32 matrices in parallel? I think that would be enough for all AI needs and easy to program.

All you really need form these in Transfofmers-dominated 2024 are GEMM and GEMV, plus fused RMS norm and some element wise primitives to apply RoPE and residuals. And all of that must be brain dead easy to install and access, and it should be cross platform. And yet no such thing exists as far as I can tell.