Vulkan Compute vs OpenCL vs CUDA ¿Cuál es la mejor API?

Ahora es el momento de comparar las APIs para cómputo basado en GPGPU y ver cuáles son las ventajas y desventajas de cada una de ellas. Así que, vamos a poner frente a frente Vulkan Compute vs OpenCL vs CUDA, y podrás ver las ventajas y desventajas de cada una y cuál te interesaría elegir. Además, también te mostraré algunas alternativas a ellas para otras máquinas…

Tabla comparativa Vulkan Compute vs OpenCL vs CUDA

	Vulkan Compute	OpenCL	CUDA
Desarrollador	Khronos Group (código abierto)	Khronos Group (código abierto)	NVIDIA (propietario)
Año de lanzamiento	2016	2009	2007
Tipo de API	Gráficos + cómputo heterogéneo	GPGPU	GPGPU
Portabilidad	Alta (multiplataforma)	Muy alta (CPU, GPU, FPGA), funciona con todo tipo de GPUs (AMD, NVIDIA, Intel,…)	Baja (solo funciona en GPUs de NVIDIA)
Nivel de control	Muy bajo nivel, explícito	Medio, más accesible	Medio-alto, optimizado
Ecosistema	Limitado	Amplio pero fragmentado debido a su portabilidad más ámplia	Muy amplio y maduro
Casos de uso	Gráficos + IA, simulaciones	Investigación (cálculo matemático paralelo o HPC), software multiplataforma	IA, HPC, producción industrial

Te podría interesar leer sobre arquitectura de GPUs

¿Qué es Vulkan Compute?

Parte de la API Vulkan, desarrollada por el Khronos Group. Es de código abierto, multiplataforma moderna, de bajo nivel, y que nació directamente de la API Mantle de AMD. AMD desarrolló Mantle para dar más control a los desarrolladores y reducir la carga de la CPU gracias a la computación heterogénea usando aceleradores GPGPU, pero finalmente donó su código y especificaciones al Khronos Group, lo que permitió la creación de Vulkan, mejorando el poryecto y adaptándolo a más dispositivos, incluidos los móviles.

Aunque Vulkan nació como API gráfica de bajo nivel, incluye compute shaders que permiten ejecutar tareas de cómputo general, es decir, para ejecutar programas de cualquier tipo en la GPU, que es más paralela que la CPU en cuanto a unidades de ejecución, lo que puede acelerar ciertas cargas.

La API principal puede trabajar con lenguajes C, C++, y también existen algunos complementos o bindings para Python, así como GLSL (OpenGL Shading Language), HLSL (High-Level Shading Language), Rust (rust-gpu), etc., para compute shaders mediante el compilador SPIR-V.

Un ejemplo de código de Hola Mundo sería:

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

int main() {
// Inicialización básica de Vulkan (instancia, dispositivo, cola)
VkInstance instance;
VkInstanceCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
vkCreateInstance(&createInfo, nullptr, &instance);

std::cout << "Hola Mundo desde la CPU!" << std::endl;
std::cout << "Hola Mundo desde la GPU (Vulkan Compute)!" << std::endl;

vkDestroyInstance(instance, nullptr);
return 0;
}

¿Qué es OpenCL?

Estándar abierto que también pertenece al Khronos Group, lanzado en 2009. Lleva más tiempo de desarrollo, y surgió en paralelo con OpenGL, la API especialmente diseñada para gráficos y que competía con DirectX de Microsoft, compatible tanto para Windows como para sistemas tipo Unix. En el caso de OpenCL, también tiene una gran compatibilidad y flexibilidad, y no solo se puede usar para programar CPUs, GPUs (como GPGPU), sino que también FPGAs para aceleradores específicos, lo cuál es un extra para la computación heterogénea frente a sus competidores.

Su modelo de programación se basa en C, tiene un amplio soporte de la comunidad, aunque está algo fragmentado debido a que puede funcionar en gran cantidad de sistemas de fabricantes diversos…  No obstante, se pueden usar otros lenguajes como C++, y bindings con Python (PyOPenCL), Java (JOCL), y más, como Fortran, Rust, Go, etc.

Un ejemplo de código fuente para cómputo heterogéneo sería:

#include <CL/cl.h>
#include <iostream>

const char* kernelSource = R"CLC(
__kernel void holaMundoOpenCL() {
printf("Hola Mundo desde la GPU (OpenCL)!\n");
}
)CLC";

int main() {
cl_int err;
cl_platform_id platform;
cl_device_id device;
cl_context context;
cl_command_queue queue;

// Plataforma y dispositivo
clGetPlatformIDs(1, &platform, nullptr);
clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, nullptr);

// Contexto y cola
context = clCreateContext(nullptr, 1, &device, nullptr, nullptr, &err);
queue = clCreateCommandQueue(context, device, 0, &err);

// Programa y kernel
cl_program program = clCreateProgramWithSource(context, 1, &kernelSource, nullptr, &err);
clBuildProgram(program, 1, &device, nullptr, nullptr, nullptr);
cl_kernel kernel = clCreateKernel(program, "holaMundoOpenCL", &err);

// Ejecuta kernel
size_t globalWorkSize = 1;
clEnqueueNDRangeKernel(queue, kernel, 1, nullptr, &globalWorkSize, nullptr, 0, nullptr, nullptr);
clFinish(queue);

std::cout << "Hola Mundo desde la CPU!" << std::endl;

// Limpieza
clReleaseKernel(kernel);
clReleaseProgram(program);
clReleaseCommandQueue(queue);
clReleaseContext(context);
return 0;
}

¿Qué es CUDA?

CUDA es la plataforma propietaria de NVIDIA, lanzada en 2007. Está optimizada para GPUs de NVIDIA compatibles, como Fermi, Kepler, Maxwell, Pascal, Volta, Turing, Ampere, Ada Lovelace, Blackwell y posteriores. No funciona por tanto en hardware que no sea de esta marca, y es un ecosistema más cerrado que los anteriores.

Esta API permite programación para acelerar IA con frameworks como TensorFlow y PyTorch, además de cómputo general (GPGPU). Todo un toolkit con todo lo necesario, desde compiladores, hasta herramientas de profiling, depuración, etc.

CUDA puede trabajar con lenguajes de programación C y C++, aunque también se pueden agregar bindings para ampliar la compatibilidad a Python (PyCUDA, CuPy, Sumba…), Fortran, Julia, Java, Rust (rust-cuda), MATLAB, etc.

Un ejemplo de código fuente para este caso sería:

#include <iostream>
#include <cuda_runtime.h>

// Kernel CUDA
__global__ void holaMundoCUDA() {
printf("Hola Mundo desde la GPU (CUDA)!\n");
}

int main() {
// Lanza el kernel con 1 bloque y 1 hilo
holaMundoCUDA<<<1, 1>>>();
cudaDeviceSynchronize();

std::cout << "Hola Mundo desde la CPU!" << std::endl;
return 0;
}

Otros

Además de los tres anteriores, existen otros proyectos similares que también merece la pena conocer:

AMD ROCm

AMD tiene un conjunto de herramientas similar a los anteriores conocido como ROCm (Radeon Open Compute). Esta plataforma de software es un stack completo, equivalente a CUDA de NVIDIA, pero para GPUs de AMD. Entre las herramientas incluye drivers, bibliotecas, el compilador HIP (Heterogeneous-compute Interface for Portability) como alternativa a nvcc de NVIDIA. Además, también existe una herramienta para convertir código de NVIDIA CUDA para que pueda correr en GPUs de AMD de forma fácil.

Puede usar lenguajes de programación varios, como C, C++, además puede usarse junto con OpenCL. Es más, también se puede emplear para IA, con PyTorch, TensorFlow, etc., sin que tenga que pasar por capas genéricas como OpenCL que son más lentas.

Apple Metal

Apple abandonó hace años estándares como OpenCL para centrarse en su propia tecnología. En los chips Apple Silicon (M-Series), el equivalente es Metal y Metal Compute. Esta API de bajo nivel ha sido desarrollada por esta compañía y optimizada especialmente para el hardware de Mac, tanto para crear videojuegos como para acelerar programas mediante cómputo con sus GPUs integradas en los SoCs.

Este proyecto incluye:

• MPS (Metal Performance Shaders): son bibliotecas para redes neuronales y cálculos matemáticos. Si usas IA en un Mac, casi siempre estarás usando MPS por debajo.
• MLX: un framework de investigación de IA lanzado por Apple específicamente para que los desarrolladores usen sus GPUs de manera eficiente, muy parecido a cómo se usa CUDA en Python.

En este caso, también se puede usar C/C++, Swift (el lenguaje propio de Apple) y otros bindings para Go, Rust, Python (metal-python), Objetive-C, etc.

Intel oneAPI

Similar a los anteriores, Intel también creó su propia API para cómputo con sus GPUs, como las Intel Arc y Xe. oneAPI se basa en el lenguaje SYCL en este caso, y su objetivo era crear un estándar que funcione en cualquier hardware, no solo en el de Intel, aunque no se ha adoptado de forma tan extensa como los anteriores…

Entre sus herramientas incluye Level Zero, SYCL y OpenMP para offloading a GPU. Puede trabajar con C/C++,  SYCL, DPC++ (Data Parallel C++), Python, y otros como Fortran, Julia, Go, etc., con la instalación de wrappers. También se puede usar con OpenCL. Incluso existen opciones para migrar desde CUDA u OpenACC.

¿Qué opinas? ¡Deja comentarios!