En informática , CUDA (originalmente Compute Unified Device Architecture ) es una plataforma de computación paralela y una interfaz de programación de aplicaciones (API) propietaria [1] que permite al software utilizar ciertos tipos de unidades de procesamiento gráfico (GPU) para un procesamiento acelerado de propósito general, un enfoque llamado computación de propósito general en GPU ( GPGPU ). API de CUDA y su tiempo de ejecución: La API de CUDA es una extensión del lenguaje de programación C que agrega la capacidad de especificar paralelismo a nivel de subproceso en C y también especificar operaciones específicas del dispositivo GPU (como mover datos entre la CPU y la GPU). [2] CUDA es una capa de software que brinda acceso directo al conjunto de instrucciones virtuales de la GPU y a los elementos computacionales paralelos para la ejecución de núcleos de cómputo . [3] Además de los controladores y los núcleos de tiempo de ejecución, la plataforma CUDA incluye compiladores, bibliotecas y herramientas para desarrolladores para ayudar a los programadores a acelerar sus aplicaciones.
CUDA está diseñado para funcionar con lenguajes de programación como C , C++ , Fortran y Python . Esta accesibilidad facilita a los especialistas en programación paralela el uso de los recursos de la GPU, a diferencia de las API anteriores como Direct3D y OpenGL , que requerían habilidades avanzadas en programación de gráficos. [4] Las GPU impulsadas por CUDA también admiten marcos de programación como OpenMP , OpenACC y OpenCL . [5] [3]
CUDA fue creado por Nvidia en 2006. [6] Cuando se introdujo por primera vez, el nombre era un acrónimo de Compute Unified Device Architecture, [7] pero Nvidia luego abandonó el uso común del acrónimo y ya no lo usa. [ ¿cuándo? ]
Ian Buck, mientras estaba en Stanford en 2000, creó una plataforma de juegos 8K usando 32 tarjetas GeForce, luego obtuvo una subvención de DARPA para realizar programación paralela de propósito general en GPU . Luego se unió a Nvidia, donde desde 2004 ha estado supervisando el desarrollo de CUDA. Al impulsar CUDA, Jensen Huang apuntó a que las GPU de Nvidia se convirtieran en un hardware general para la computación científica. CUDA se lanzó en 2006. Alrededor de 2015, el enfoque de CUDA cambió a redes neuronales. [8]
Ontología
La siguiente tabla ofrece una descripción no exacta de la ontología del marco CUDA.
Habilidades de programación
La plataforma CUDA es accesible para los desarrolladores de software a través de bibliotecas aceleradas por CUDA, directivas de compilación como OpenACC y extensiones a lenguajes de programación estándar de la industria, incluidos C , C++ , Fortran y Python . Los programadores de C/C++ pueden usar 'CUDA C/C++', compilado en PTX con nvcc , el compilador C/C++ basado en LLVM de Nvidia, o mediante el propio clang. [9] Los programadores de Fortran pueden usar 'CUDA Fortran', compilado con el compilador PGI CUDA Fortran de The Portland Group . [ necesita actualización ] Los programadores de Python pueden usar la biblioteca cuNumeric para acelerar aplicaciones en las GPU de Nvidia.
Además de bibliotecas, directivas de compilador, CUDA C/C++ y CUDA Fortran, la plataforma CUDA admite otras interfaces computacionales, incluyendo OpenCL de Khronos Group , [10] DirectCompute de Microsoft , OpenGL Compute Shader y C++ AMP . [11] También hay disponibles envoltorios de terceros para Python , Perl , Fortran, Java , Ruby , Lua , Common Lisp , Haskell , R , MATLAB , IDL , Julia y soporte nativo en Mathematica .
CUDA proporciona una API de bajo nivel (CUDA Driver API, no de fuente única) y una API de nivel superior (CUDA Runtime API, de fuente única). El SDK inicial de CUDA se hizo público el 15 de febrero de 2007, para Microsoft Windows y Linux . Posteriormente se agregó compatibilidad con Mac OS X en la versión 2.0, [17] que reemplaza a la versión beta lanzada el 14 de febrero de 2008. [18] CUDA funciona con todas las GPU de Nvidia desde la serie G8x en adelante, incluidas GeForce , Quadro y la línea Tesla . CUDA es compatible con la mayoría de los sistemas operativos estándar.
CUDA 8.0 viene con las siguientes bibliotecas (para compilación y tiempo de ejecución, en orden alfabético):
cuBLAS – Biblioteca de subrutinas de álgebra lineal básica de CUDA
CUDART – Biblioteca de ejecución CUDA
cuFFT – Biblioteca de transformada rápida de Fourier CUDA
cuRAND – Biblioteca de generación de números aleatorios CUDA
cuSOLVER: colección de solucionadores directos densos y dispersos basada en CUDA
cuSPARSE – Biblioteca de matrices dispersas de CUDA
NPP: biblioteca de primitivas de rendimiento de NVIDIA
nvGRAPH: biblioteca de análisis de gráficos de NVIDIA
NVML – Biblioteca de administración de NVIDIA
NVRTC: biblioteca de compilación en tiempo de ejecución de NVIDIA para CUDA C++
CUDA 8.0 viene con estos otros componentes de software:
nView: software de gestión de escritorio NVIDIA nView
NVWMI: kit de herramientas de gestión empresarial de NVIDIA
GameWorks PhysX : es un motor de física de juegos multiplataforma
CUDA 9.0–9.2 viene con estos otros componentes:
CUTLASS 1.0 – algoritmos de álgebra lineal personalizados,
NVIDIA Video Decoder quedó obsoleto en CUDA 9.2; ahora está disponible en NVIDIA Video Codec SDK
CUDA 10 viene con estos otros componentes:
nvJPEG: procesamiento híbrido de JPEG (CPU y GPU)
CUDA 11.0–11.8 viene con estos otros componentes: [19] [20] [21] [22]
CUB es una de las nuevas bibliotecas de C++ con más soporte
Compatibilidad con GPU de múltiples instancias MIG
nvJPEG2000 – Codificador y decodificador JPEG 2000
Ventajas
CUDA tiene varias ventajas sobre el cálculo tradicional de propósito general en GPU (GPGPU) utilizando API de gráficos:
Lecturas dispersas: el código puede leer desde direcciones arbitrarias en la memoria.
Memoria virtual unificada (CUDA 4.0 y superior)
Memoria unificada (CUDA 6.0 y superior)
Memoria compartida : CUDA expone una región de memoria compartida rápida que puede compartirse entre subprocesos. Esta puede usarse como caché administrada por el usuario, lo que permite un mayor ancho de banda que el que se puede lograr con búsquedas de texturas. [23]
Descargas y lecturas más rápidas hacia y desde la GPU
Soporte completo para operaciones de números enteros y bit a bit, incluidas búsquedas de texturas de números enteros
Limitaciones
Ya sea para el ordenador anfitrión o para el dispositivo GPU, todo el código fuente de CUDA se procesa ahora según las reglas de sintaxis de C++. [24] Este no siempre fue el caso. Las versiones anteriores de CUDA se basaban en las reglas de sintaxis de C. [25] Al igual que con el caso más general de compilar código C con un compilador de C++, es posible que el antiguo código fuente de CUDA de estilo C no se compile o no se comporte como se pretendía originalmente.
La interoperabilidad con lenguajes de renderizado como OpenGL es unidireccional: OpenGL tiene acceso a la memoria CUDA registrada, pero CUDA no tiene acceso a la memoria OpenGL.
La copia entre la memoria del host y del dispositivo puede provocar una pérdida de rendimiento debido al ancho de banda del bus del sistema y la latencia (esto se puede aliviar en parte con transferencias de memoria asincrónicas, manejadas por el motor DMA de la GPU).
Los subprocesos deben ejecutarse en grupos de al menos 32 para obtener el mejor rendimiento, con un número total de subprocesos de miles. Las bifurcaciones en el código del programa no afectan significativamente el rendimiento, siempre que cada uno de los 32 subprocesos tome la misma ruta de ejecución; el modelo de ejecución SIMD se convierte en una limitación significativa para cualquier tarea inherentemente divergente (por ejemplo, atravesar una estructura de datos de partición espacial durante el trazado de rayos ).
No hay ninguna funcionalidad de emulación o respaldo disponible para las revisiones modernas.
A veces, el código C++ válido puede estar marcado y evitar la compilación debido a la forma en que el compilador aborda la optimización para las limitaciones del dispositivo GPU de destino. [ cita requerida ]
En la matemática de precisión simple de los dispositivos de capacidad de cómputo CUDA 1.x de primera generación, los números desnormalizados no son compatibles y, en su lugar, se ponen a cero, y la precisión de las operaciones de división y raíz cuadrada son ligeramente inferiores a las matemáticas de precisión simple compatibles con IEEE 754. Los dispositivos que admiten capacidad de cómputo 2.0 y superiores admiten números desnormalizados, y las operaciones de división y raíz cuadrada son compatibles con IEEE 754 de forma predeterminada. Sin embargo, los usuarios pueden obtener las matemáticas de grado de juego más rápidas anteriores de los dispositivos con capacidad de cómputo 1.x si lo desean, configurando indicadores del compilador para deshabilitar divisiones precisas y raíces cuadradas precisas, y habilitar el vaciado de números desnormalizados a cero. [26]
A diferencia de OpenCL , las GPU compatibles con CUDA solo están disponibles en Nvidia, ya que es una tecnología propietaria. [27] [1] Los intentos de implementar CUDA en otras GPU incluyen:
Proyecto Coriander: convierte el código fuente de CUDA C++11 a OpenCL 1.2 C. Una bifurcación de CUDA-on-CL destinada a ejecutar TensorFlow . [28] [29] [30]
CU2CL: Convierte CUDA 3.2 C++ a OpenCL C. [31]
GPUOpen HIP: una fina capa de abstracción sobre CUDA y ROCm pensada para GPU AMD y Nvidia. Tiene una herramienta de conversión para importar código fuente CUDA C++. Admite CUDA 4.0 más C++11 y float16.
ZLUDA es un reemplazo directo de CUDA en las GPU de AMD y, anteriormente, en las GPU de Intel con un rendimiento casi nativo. [32] El desarrollador, Andrzej Janik, fue contratado por separado tanto por Intel como por AMD para desarrollar el software en 2021 y 2022, respectivamente. Sin embargo, ninguna de las empresas decidió lanzarlo oficialmente debido a la falta de un caso de uso comercial. El contrato de AMD incluía una cláusula que permitía a Janik publicar su código para AMD de forma independiente, lo que le permitía lanzar la nueva versión que solo es compatible con las GPU de AMD. [33]
chipStar puede compilar y ejecutar programas CUDA/HIP en plataformas avanzadas OpenCL 3.0 o Level Zero. [34]
Ejemplo
Este código de ejemplo en C++ carga una textura de una imagen en una matriz en la GPU:
textura < float , 2 , cudaReadModeElementType > tex ;void foo () { cudaArray * cu_array ;// Asignar matriz cudaChannelFormatDesc descripción = cudaCreateChannelDesc < float > (); cudaMallocArray ( & cu_array , & descripción , ancho , alto );// Copiar datos de imagen a la matriz cudaMemcpyToArray ( cu_array , image , width * height * sizeof ( float ), cudaMemcpyHostToDevice );// Establecer parámetros de textura (predeterminado) tex . addressMode [ 0 ] = cudaAddressModeClamp ; tex . addressMode [ 1 ] = cudaAddressModeClamp ; tex . filterMode = cudaFilterModePoint ; tex . normalized = false ; // no normalizar las coordenadas// Vincula la matriz a la textura cudaBindTextureToArray ( tex , cu_array );// Ejecutar kernel dim3 blockDim ( 16 , 16 , 1 ); dim3 gridDim (( ancho + blockDim . x - 1 ) / blockDim . x , ( alto + blockDim . y - 1 ) / blockDim . y , 1 ); kernel <<< gridDim , blockDim , 0 >>> ( d_data , alto , ancho );// Desvincular la matriz de la textura cudaUnbindTexture ( tex ); } //fin foo()__global__ void kernel ( float * odata , int altura , int ancho ) { entero sin signo x = blockIdx.x * blockDim.x + threadIdx.x ; entero sin signo y = blockIdx.y * blockDim.y + threadIdx.y ; if ( x < ancho && y < alto ) { float c = tex2D ( tex , x , y ) ; odata [ y * ancho + x ] = c ; } }
A continuación se muestra un ejemplo en Python que calcula el producto de dos matrices en la GPU. Los enlaces no oficiales del lenguaje Python se pueden obtener de PyCUDA . [35]
importar pycuda.compiler como comp importar pycuda.driver como drv importar numpy importar pycuda.autoinitmod = comp . MóduloOrigen ( """ __global__ void multiplicarlos(float *dest, float *a, float *b) { const int i = threadIdx.x; dest[i] = a[i] * b[i]; } """ )multiplicarlos = mod .get_function ( " multiplicarlos" )a = numpy . random . randn ( 400 ) . astype ( numpy . float32 ) b = numpy . random . randn ( 400 ) . astype ( numpy . float32 )dest = numpy . ceros_similares ( a ) multiplicarlos ( drv . salida ( dest ), drv . entrada ( a ), drv . entrada ( b ), bloque = ( 400 , 1 , 1 ))imprimir ( dest - a * b )
Se pueden encontrar enlaces de Python adicionales para simplificar las operaciones de multiplicación de matrices en el programa pycublas . [36]
Mientras que CuPy reemplaza directamente a NumPy: [37]
Importar cupya = cupy . aleatorio . randn ( 400 ) b = cupy . aleatorio . randn ( 400 )destino = cupy . ceros_como ( a )imprimir ( dest - a * b )
GPU compatibles
Versiones de capacidad de cómputo CUDA compatibles con la versión del SDK de CUDA y la microarquitectura (por nombre de código):
Nota: CUDA SDK 10.2 es la última versión oficial para macOS, ya que el soporte no estará disponible para macOS en versiones más nuevas.
Capacidad de cómputo de CUDA por versión con semiconductores de GPU asociados y modelos de tarjetas GPU (separados por sus diversas áreas de aplicación):
Whereas Nvidia's CUDA is closed-source, Intel's OneAPI and AMD's ROCm are open source.
Intel OneAPI
oneAPI is an initiative based in open standards, created to support software development for multiple hardware architectures.[122] The oneAPI libraries must implement open specifications that are discussed publicly by the Special Interest Groups, offering the possibility for any developer or organization to implemente their own versions of oneAPI libraries.[123][124]
Originally made by Intel, other hardware adopters include Fujitsu and Huawei.
Unified Acceleration Foundation (UXL)
Unified Acceleration Foundation (UXL) is a new technology consortium working on the continuation of the OneAPI initiative, with the goal to create a new open standard accelerator software ecosystem, related open standards and specification projects through Working Groups and Special Interest Groups (SIGs). The goal is to offer open alternatives to Nvidia's CUDA. The main companies behind it are Intel, Google, ARM, Qualcomm, Samsung, Imagination, and VMware.[125]
SYCL – an open standard from Khronos Group for programming a variety of platforms, including GPUs, with single-source modern C++, similar to higher-level CUDA Runtime API (single-source)
BrookGPU – the Stanford University graphics group's compiler
^DirectCompute Ocean Demo Running on Nvidia CUDA-enabled GPU on YouTube
^Vasiliadis, Giorgos; Antonatos, Spiros; Polychronakis, Michalis; Markatos, Evangelos P.; Ioannidis, Sotiris (September 2008). "Gnort: High Performance Network Intrusion Detection Using Graphics Processors" (PDF). Recent Advances in Intrusion Detection. Lecture Notes in Computer Science. Vol. 5230. pp. 116–134. doi:10.1007/978-3-540-87403-4_7. ISBN 978-3-540-87402-7.
^Schatz, Michael C.; Trapnell, Cole; Delcher, Arthur L.; Varshney, Amitabh (2007). "High-throughput sequence alignment using Graphics Processing Units". BMC Bioinformatics. 8: 474. doi:10.1186/1471-2105-8-474. PMC 2222658. PMID 18070356.
^Manavski, Svetlin A.; Giorgio, Valle (2008). "CUDA compatible GPU cards as efficient hardware accelerators for Smith-Waterman sequence alignment". BMC Bioinformatics. 10 (Suppl 2): S10. doi:10.1186/1471-2105-9-S2-S10. PMC 2323659. PMID 18387198.
^"Pyrit – Google Code".
^"Use your Nvidia GPU for scientific computing". BOINC. 2008-12-18. Archived from the original on 2008-12-28. Retrieved 2017-08-08.
^"Nvidia CUDA Software Development Kit (CUDA SDK) – Release Notes Version 2.0 for MAC OS X". Archived from the original on 2009-01-06.
^"CUDA 1.1 – Now on Mac OS X". February 14, 2008. Archived from the original on November 22, 2008.
^"CUDA 11 Features Revealed". 14 May 2020.
^"CUDA Toolkit 11.1 Introduces Support for GeForce RTX 30 Series and Quadro RTX Series GPUs". 23 September 2020.
^"Enhancing Memory Allocation with New NVIDIA CUDA 11.2 Features". 16 December 2020.
^"Exploring the New Features of CUDA 11.3". 16 April 2021.
^Silberstein, Mark; Schuster, Assaf; Geiger, Dan; Patney, Anjul; Owens, John D. (2008). "Efficient computation of sum-products on GPUs through software-managed cache" (PDF). Proceedings of the 22nd annual international conference on Supercomputing – ICS '08 (PDF). Proceedings of the 22nd annual international conference on Supercomputing – ICS '08. pp. 309–318. doi:10.1145/1375527.1375572. ISBN 978-1-60558-158-3.
^"CUDA C Programming Guide v8.0" (PDF). nVidia Developer Zone. January 2017. p. 19. Retrieved 22 March 2017.
^"NVCC forces c++ compilation of .cu files". 29 November 2011.
^Whitehead, Nathan; Fit-Florea, Alex. "Precision & Performance: Floating Point and IEEE 754 Compliance for Nvidia GPUs" (PDF). Nvidia. Retrieved November 18, 2014.
^"CUDA-Enabled Products". CUDA Zone. Nvidia Corporation. Retrieved 2008-11-03.
^"Coriander Project: Compile CUDA Codes To OpenCL, Run Everywhere". Phoronix.
^Perkins, Hugh (2017). "cuda-on-cl" (PDF). IWOCL. Retrieved August 8, 2017.
^"hughperkins/coriander: Build NVIDIA® CUDA™ code for OpenCL™ 1.2 devices". GitHub. May 6, 2019.
^Luo, Weile; Fan, Ruibo; Li, Zeyu; Du, Dayou; Wang, Qiang; Chu, Xiaowen (2024). "Benchmarking and Dissecting the Nvidia Hopper GPU Architecture". arXiv:2402.13499v1 [cs.AR].
^"Datasheet NVIDIA A40" (PDF). nvidia.com. Retrieved 27 April 2024.
^"NVIDIA AMPERE GA102 GPU ARCHITECTURE" (PDF). 27 April 2024.
^"Datasheet NVIDIA L40" (PDF). 27 April 2024.
^In the Whitepapers the Tensor Core cube diagrams represent the Dot Product Unit Width into the height (4 FP16 for Volta and Turing, 8 FP16 for A100, 4 FP16 for GA102, 16 FP16 for GH100). The other two dimensions represent the number of Dot Product Units (4x4 = 16 for Volta and Turing, 8x4 = 32 for Ampere and Hopper). The resulting gray blocks are the FP16 FMA operations per cycle. Pascal without Tensor core is only shown for speed comparison as is Volta V100 with non-FP16 datatypes.
^"NVIDIA Turing Architecture Whitepaper" (PDF). nvidia.com. Retrieved 5 September 2023.
^"NVIDIA Tensor Core GPU" (PDF). nvidia.com. Retrieved 5 September 2023.
^"NVIDIA Hopper Architecture In-Depth". 22 March 2022.
^shape x converted operand size, e.g. 2 tensor cores x 4x4x4xFP16/cycle = 256 Bytes/cycle
^= product first 3 table rows
^= product of previous 2 table rows; shape: e.g. 8x8x4xFP16 = 512 Bytes
^Sun, Wei; Li, Ang; Geng, Tong; Stuijk, Sander; Corporaal, Henk (2023). "Dissecting Tensor Cores via Microbenchmarks: Latency, Throughput and Numeric Behaviors". IEEE Transactions on Parallel and Distributed Systems. 34 (1): 246–261. arXiv:2206.02874. doi:10.1109/tpds.2022.3217824. S2CID 249431357.
^"Parallel Thread Execution ISA Version 7.7".
^Raihan, Md Aamir; Goli, Negar; Aamodt, Tor (2018). "Modeling Deep Learning Accelerator Enabled GPUs". arXiv:1811.08309 [cs.MS].
^"NVIDIA Ada Lovelace Architecture".
^shape x converted operand size, e.g. 2 tensor cores x 4x4x4xFP16/cycle = 256 Bytes/cycle
^= product first 3 table rows
^= product of previous 2 table rows; shape: e.g. 8x8x4xFP16 = 512 Bytes
^Jia, Zhe; Maggioni, Marco; Smith, Jeffrey; Daniele Paolo Scarpazza (2019). "Dissecting the NVidia Turing T4 GPU via Microbenchmarking". arXiv:1903.07486 [cs.DC].
^Burgess, John (2019). "RTX ON – The NVIDIA TURING GPU". 2019 IEEE Hot Chips 31 Symposium (HCS). pp. 1–27. doi:10.1109/HOTCHIPS.2019.8875651. ISBN 978-1-7281-2089-8. S2CID 204822166.
^Jia, Zhe; Maggioni, Marco; Smith, Jeffrey; Daniele Paolo Scarpazza (2019). "Dissecting the NVidia Turing T4 GPU via Microbenchmarking". arXiv:1903.07486 [cs.DC].
^Burgess, John (2019). "RTX ON – The NVIDIA TURING GPU". 2019 IEEE Hot Chips 31 Symposium (HCS). pp. 1–27. doi:10.1109/HOTCHIPS.2019.8875651. ISBN 978-1-7281-2089-8. S2CID 204822166.
^dependent on device
^"Tegra X1". 9 January 2015.
^NVIDIA H100 Tensor Core GPU Architecture
^H.1. Features and Technical Specifications – Table 14. Technical Specifications per Compute Capability
^NVIDIA Hopper Architecture In-Depth
^can only execute 160 integer instructions according to programming guide
^128 according to [1]. 64 from FP32 + 64 separate units?
^64 by FP32 cores and 64 by flexible FP32/INT cores.
^"CUDA C++ Programming Guide".
^32 FP32 lanes combine to 16 FP64 lanes. Maybe lower depending on model.
^only supported by 16 FP32 lanes, they combine to 4 FP64 lanes
^ a b c d e fdepending on model
^Effective speed, probably over FP32 ports. No description of actual FP64 cores.
^Can also be used for integer additions and comparisons
^2 clock cycles/instruction for each SM partition Burgess, John (2019). "RTX ON – The NVIDIA TURING GPU". 2019 IEEE Hot Chips 31 Symposium (HCS). pp. 1–27. doi:10.1109/HOTCHIPS.2019.8875651. ISBN 978-1-7281-2089-8. S2CID 204822166.
^Durant, Luke; Giroux, Olivier; Harris, Mark; Stam, Nick (May 10, 2017). "Inside Volta: The World's Most Advanced Data Center GPU". Nvidia developer blog.
^The schedulers and dispatchers have dedicated execution units unlike with Fermi and Kepler.
^Dispatching can overlap concurrently, if it takes more than one cycle (when there are less execution units than 32/SM Partition)
^Can dual issue MAD pipe and SFU pipe
^No more than one scheduler can issue 2 instructions at once. The first scheduler is in charge of warps with odd IDs. The second scheduler is in charge of warps with even IDs.
^ a bshared memory only, no data cache
^ a b c d e fshared memory separate, but L1 includes texture cache
^"Demystifying GPU Microarchitecture through Microbenchmarking" (PDF).
^Jia, Zhe; Maggioni, Marco; Staiger, Benjamin; Scarpazza, Daniele P. (2018). "Dissecting the NVIDIA Volta GPU Architecture via Microbenchmarking". arXiv:1804.06826 [cs.DC].
^"Tegra X1". 9 January 2015.
^Jia, Zhe; Maggioni, Marco; Smith, Jeffrey; Daniele Paolo Scarpazza (2019). "Dissecting the NVidia Turing T4 GPU via Microbenchmarking". arXiv:1903.07486 [cs.DC].
^"Dissecting the Ampere GPU Architecture through Microbenchmarking".
^Note that Jia, Zhe; Maggioni, Marco; Smith, Jeffrey; Daniele Paolo Scarpazza (2019). "Dissecting the NVidia Turing T4 GPU via Microbenchmarking". arXiv:1903.07486 [cs.DC]. disagrees and states 2 KiB L0 instruction cache per SM partition and 16 KiB L1 instruction cache per SM
^Jia, Zhe; Maggioni, Marco; Staiger, Benjamin; Scarpazza, Daniele P. (2018). "Dissecting the NVIDIA Volta GPU Architecture via Microbenchmarking". arXiv:1804.06826 [cs.DC].
^"Exclusive: Behind the plot to break Nvidia's grip on AI by targeting software". Reuters. Retrieved 2024-04-05.
^"Question: What does ROCm stand for? · Issue #1628 · RadeonOpenCompute/ROCm". Github.com. Retrieved January 18, 2022.
Further reading
Buck, Ian; Foley, Tim; Horn, Daniel; Sugerman, Jeremy; Fatahalian, Kayvon; Houston, Mike; Hanrahan, Pat (2004-08-01). "Brook for GPUs: stream computing on graphics hardware". ACM Transactions on Graphics. 23 (3): 777–786. doi:10.1145/1015706.1015800. ISSN 0730-0301.
Nickolls, John; Buck, Ian; Garland, Michael; Skadron, Kevin (2008-03-01). "Scalable Parallel Programming with CUDA: Is CUDA the parallel programming model that application developers have been waiting for?". Queue. 6 (2): 40–53. doi:10.1145/1365490.1365500. ISSN 1542-7730.