repository·master·Indexed 25 days ago
https://github.com/komputeproject/komputeA cross-vendor GPU compute framework built on Vulkan for high-performance tasks such as machine learning and mobile acceleration. It supports C++ and Python and provides examples for Android, Raspberry Pi 4, and integration with the Godot game engine via custom modules or GDNative.
This example demonstrates how to integrate Kompute for GPU-accelerated machine learning within the Godot game engine. It is based on the technical guide "Supercharging Game Development with GPU Accelerated Machine Learning".
The example is composed of three main parts:
project.godot file used to run the visual demonstration.For a simpler GPU-based example, refer to the godot_examples directory.
/docs/overview within the repository.Kompute is built on a hierarchy of abstractions that manage the relationship between CPU (Host) and GPU (Device) memory and execution:
kp::Manager): The high-level entry point that simplifies interaction with GPU sequences and operations.kp::Sequence): A batch of operations executed on a specific GPU queue. Sequences can be executed synchronously or asynchronously and are coordinated via vk::Fence.kp::Tensor): The atomic unit of data in Kompute, used to handle both Host and GPU Device data.kp::Algorithm): Encapsulates the components required for shader execution, including vk::Pipeline and vk::DescriptorSet resources.kp::OpBase): A single step executed during a GPU submission. Operations can involve one or more kp::Tensor objects.The kp.Tensor component manages data in GPU memory. It uses numpy arrays to wrap GPU memory, providing a primary interface to the GPU.
Memory Management Lifecycle:
destroy() is explicitly called..data(): Calling .data() on a tensor returns a numpy array that adds an extra reference count to the underlying resources. The resources will not be destroyed until this numpy array object is also destroyed.Example of memory lifecycle behavior:
import kp
m = kp.Manager()
t = m.tensor([1,2,3])
# td holds a reference to the underlying tensor memory
td = t.data()
del t
# td is still valid because of the extra refcount from .data()
assert td.base.is_init() == True
m.destroy() # Frees all memory inside tensors
# After manager destruction, the underlying resource is no longer initialized
assert td.base.is_init() == False
del td # Now the tensor destructor is called as refcount reaches 0import kp
m = kp.Manager()
t = m.tensor([1,2,3])
td = t.data()
del t
assert td.base.is_init() == True
m.destroy()
assert td.base.is_init() == False
del tdkp.Tensor is the atomic unit in Kompute. It is used to manage and transfer data between the Host (CPU) and the GPU Device memory.Kompute is organized into several key abstractions that manage the lifecycle of GPU computations:
The Kompute Python package is built around three primary classes:
kp.Manager: Manages high-level GPU and Kompute resources.kp.Sequence: Contains a set of recorded operations that can be reused.kp.Tensor: The core data component used to manage GPU and host data for operations.Note that kp.OpBase and its subclasses are not directly exposed in Python. Instead, you interact with operations through kp.Manager or kp.Sequence methods.
Kompute uses an extensible architecture where core components can be extended by building custom operations. All operations inherit from the kp::OpBase class.
To create operations that include custom shader logic (requiring Compute Pipelines, DescriptorSets, etc.), you should inherit from kp::OpAlgoBase instead of the generic kp::OpBase.
Understanding the lifecycle of an operation is critical because functions are called in a specific sequence during execution. This sequence ensures that resources are correctly initialized, commands are recorded to the Vulkan command buffer, and data is synchronized between host and device memory.
Kompute provides several core capabilities for GPU acceleration:
Kompute is optimized for mobile environments, specifically Android.
Kompute follows a hierarchical, acyclic ownership model for memory management. Key principles include:
kp::Manager) acts as the primary owner of GPU resources and ensures all resources it owns are released when the manager is destroyed.