CUDA

Parallel computing platform and programming model

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? ]}

Fondo

La unidad de procesamiento gráfico (GPU), como procesador informático especializado, atiende las demandas de tareas de procesamiento intensivo de gráficos 3D de alta resolución en tiempo real . En 2012, las GPU habían evolucionado hasta convertirse en sistemas multinúcleo altamente paralelos que permiten la manipulación eficiente de grandes bloques de datos. Este diseño es más eficaz que las unidades centrales de procesamiento (CPU) de propósito general para algoritmos en situaciones en las que el procesamiento de grandes bloques de datos se realiza en paralelo, como:

• funciones hash criptográficas
• aprendizaje automático
• simulaciones de dinámica molecular
• motores de fisica

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

Ejemplo de flujo de procesamiento de CUDA

1. Copiar datos de la memoria principal a la memoria de la GPU
2. La CPU inicia el núcleo de cómputo de la GPU
3. Los núcleos CUDA de la GPU ejecutan el kernel en paralelo
4. Copiar los datos resultantes de la memoria de la GPU a la memoria principal

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 .

En la industria de los videojuegos , las GPU se utilizan para la representación de gráficos y para los cálculos de física del juego (efectos físicos como escombros, humo, fuego, fluidos); algunos ejemplos son PhysX y Bullet . CUDA también se ha utilizado para acelerar aplicaciones no gráficas en biología computacional , criptografía y otros campos en un orden de magnitud o más. ^{[12] [13] [14] [15] [16]}

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 ]}
• La información de tipo de tiempo de ejecución de C++ (RTTI) y el manejo de excepciones al estilo C++ solo se admiten en el código del host, no en el código del dispositivo.
• 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]

 importar  numpy desde  pycublas  importar  CUBLASMatrixA  =  MatrizCUBLAS ( numpy.mat ( [ [ 1,2,3 ] , [ 4,5,6 ] ] , numpy.float32 ) ) B = MatrizCUBLAS ( numpy.mat ( [ [ 2,3 ] , [ 4,5 ] , [ 6,7 ] ] , numpy.float32 ) ) C = A * B print ( C.np_mat ( ) )​​​​​​​​​                  

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):

'*' – Productos exclusivos de OEM

Características y especificaciones de la versión

^[57]

Tipos de datos

Nota: Cualquier línea faltante o entrada vacía refleja cierta falta de información sobre ese elemento exacto. ^[58]

Núcleos tensoriales

Nota: Cualquier línea faltante o entrada vacía refleja cierta falta de información sobre ese elemento exacto. ^{[61] [62] [63] [64] [65] [66]}

^{[74] [75] [76] [77]}

Especificaciones técnicas

^[88]

^[89]

Arquitectura multiprocesador

^[118]

For more information read the Nvidia CUDA programming guide.^[119]

Current and future usages of CUDA architecture

• Accelerated rendering of 3D graphics
• Accelerated interconversion of video file formats
• Accelerated encryption, decryption and compression
• Bioinformatics, e.g. NGS DNA sequencing BarraCUDA^[120]
• Distributed calculations, such as predicting the native conformation of proteins
• Medical analysis simulations, for example virtual reality based on CT and MRI scan images
• Physical simulations,^[121] in particular in fluid dynamics
• Neural network training in machine learning problems
• Large Language Model inference
• Face recognition
• Volunteer computing projects, such as SETI@home and other projects using BOINC software
• Molecular dynamics
• Mining cryptocurrencies
• Structure from motion (SfM) software

Comparison with competitors

CUDA competes with other GPU computing stacks: Intel OneAPI and AMD ROCm.

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]

AMD ROCm

ROCm^[126] is an open source software stack for graphics processing unit (GPU) programming from Advanced Micro Devices (AMD).

See also

• 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
• Array programming
• Parallel computing
• Stream processing
• rCUDA – an API for computing on remote computers
• Molecular modeling on GPUs
• Vulkan – low-level, high-performance 3D graphics and computing API
• OptiX – ray tracing API by NVIDIA
• CUDA binary (cubin) – a type of fat binary
• Numerical Library Collection – by NEC for their vector processor

References

1. Shah, Agam. "Nvidia not totally against third parties making CUDA chips". www.theregister.com. Retrieved 2024-04-25.
2. Nvidia. "What is CUDA?". Nvidia. Retrieved 21 March 2024.
3. Abi-Chahla, Fedy (June 18, 2008). "Nvidia's CUDA: The End of the CPU?". Tom's Hardware. Retrieved May 17, 2015.
4. Zunitch, Peter (2018-01-24). "CUDA vs. OpenCL vs. OpenGL". Videomaker. Retrieved 2018-09-16.
5. "OpenCL". NVIDIA Developer. 2013-04-24. Retrieved 2019-11-04.
6. "Nvidia CUDA Home Page". 18 July 2017.
7. Shimpi, Anand Lal; Wilson, Derek (November 8, 2006). "Nvidia's GeForce 8800 (G80): GPUs Re-architected for DirectX 10". AnandTech. Retrieved May 16, 2015.
8. Witt, Stephen (2023-11-27). "How Jensen Huang's Nvidia Is Powering the A.I. Revolution". The New Yorker. ISSN 0028-792X. Retrieved 2023-12-10.
9. "CUDA LLVM Compiler". 7 May 2012.
10. First OpenCL demo on a GPU on YouTube
11. DirectCompute Ocean Demo Running on Nvidia CUDA-enabled GPU on YouTube
12. 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.
13. 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.
14. 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.
15. "Pyrit – Google Code".
16. "Use your Nvidia GPU for scientific computing". BOINC. 2008-12-18. Archived from the original on 2008-12-28. Retrieved 2017-08-08.
17. "Nvidia CUDA Software Development Kit (CUDA SDK) – Release Notes Version 2.0 for MAC OS X". Archived from the original on 2009-01-06.
18. "CUDA 1.1 – Now on Mac OS X". February 14, 2008. Archived from the original on November 22, 2008.
19. "CUDA 11 Features Revealed". 14 May 2020.
20. "CUDA Toolkit 11.1 Introduces Support for GeForce RTX 30 Series and Quadro RTX Series GPUs". 23 September 2020.
21. "Enhancing Memory Allocation with New NVIDIA CUDA 11.2 Features". 16 December 2020.
22. "Exploring the New Features of CUDA 11.3". 16 April 2021.
23. 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.
24. "CUDA C Programming Guide v8.0" (PDF). nVidia Developer Zone. January 2017. p. 19. Retrieved 22 March 2017.
25. "NVCC forces c++ compilation of .cu files". 29 November 2011.
26. Whitehead, Nathan; Fit-Florea, Alex. "Precision & Performance: Floating Point and IEEE 754 Compliance for Nvidia GPUs" (PDF). Nvidia. Retrieved November 18, 2014.
27. "CUDA-Enabled Products". CUDA Zone. Nvidia Corporation. Retrieved 2008-11-03.
28. "Coriander Project: Compile CUDA Codes To OpenCL, Run Everywhere". Phoronix.
29. Perkins, Hugh (2017). "cuda-on-cl" (PDF). IWOCL. Retrieved August 8, 2017.
30. "hughperkins/coriander: Build NVIDIA® CUDA™ code for OpenCL™ 1.2 devices". GitHub. May 6, 2019.
31. "CU2CL Documentation". chrec.cs.vt.edu.
32. "GitHub – vosen/ZLUDA". GitHub.
33. Larabel, Michael (2024-02-12), "AMD Quietly Funded A Drop-In CUDA Implementation Built On ROCm: It's Now Open-Source", Phoronix, retrieved 2024-02-12
34. "GitHub – chip-spv/chipStar". GitHub.
35. "PyCUDA".
36. "pycublas". Archived from the original on 2009-04-20. Retrieved 2017-08-08.
37. "CuPy". Retrieved 2020-01-08.
38. "NVIDIA CUDA Programming Guide. Version 1.0" (PDF). June 23, 2007.
39. "NVIDIA CUDA Programming Guide. Version 2.1" (PDF). December 8, 2008.
40. "NVIDIA CUDA Programming Guide. Version 2.2" (PDF). April 2, 2009.
41. "NVIDIA CUDA Programming Guide. Version 2.2.1" (PDF). May 26, 2009.
42. "NVIDIA CUDA Programming Guide. Version 2.3.1" (PDF). August 26, 2009.
43. "NVIDIA CUDA Programming Guide. Version 3.0" (PDF). February 20, 2010.
44. "NVIDIA CUDA C Programming Guide. Version 3.1.1" (PDF). July 21, 2010.
45. "NVIDIA CUDA C Programming Guide. Version 3.2" (PDF). November 9, 2010.
46. "CUDA 11.0 Release Notes". NVIDIA Developer.
47. "CUDA 11.1 Release Notes". NVIDIA Developer.
48. "CUDA 11.5 Release Notes". NVIDIA Developer.
49. "CUDA 11.8 Release Notes". NVIDIA Developer.
50. "NVIDIA Quadro NVS 420 Specs". TechPowerUp GPU Database. 25 August 2023.
51. Larabel, Michael (March 29, 2017). "NVIDIA Rolls Out Tegra X2 GPU Support In Nouveau". Phoronix. Retrieved August 8, 2017.
52. Nvidia Xavier Specs on TechPowerUp (preliminary)
53. "Welcome — Jetson LinuxDeveloper Guide 34.1 documentation".
54. "NVIDIA Bringing up Open-Source Volta GPU Support for Their Xavier SoC".
55. "NVIDIA Ada Lovelace Architecture".
56. Dissecting the Turing GPU Architecture through Microbenchmarking
57. "H.1. Features and Technical Specifications – Table 13. Feature Support per Compute Capability". docs.nvidia.com. Retrieved 2020-09-23.
58. "CUDA C++ Programming Guide".
59. Fused-Multiply-Add, actually executed, Dense Matrix
60. as SASS since 7.5, as PTX since 8.0
61. "Technical brief. NVIDIA Jetson AGX Orin Series" (PDF). nvidia.com. Retrieved 5 September 2023.
62. "NVIDIA Ampere GA102 GPU Architecture" (PDF). nvidia.com. Retrieved 5 September 2023.
63. 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].
64. "Datasheet NVIDIA A40" (PDF). nvidia.com. Retrieved 27 April 2024.
65. "NVIDIA AMPERE GA102 GPU ARCHITECTURE" (PDF). 27 April 2024.
66. "Datasheet NVIDIA L40" (PDF). 27 April 2024.
67. 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.
68. "NVIDIA Turing Architecture Whitepaper" (PDF). nvidia.com. Retrieved 5 September 2023.
69. "NVIDIA Tensor Core GPU" (PDF). nvidia.com. Retrieved 5 September 2023.
70. "NVIDIA Hopper Architecture In-Depth". 22 March 2022.
71. shape x converted operand size, e.g. 2 tensor cores x 4x4x4xFP16/cycle = 256 Bytes/cycle
72. = product first 3 table rows
73. = product of previous 2 table rows; shape: e.g. 8x8x4xFP16 = 512 Bytes
74. 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.
75. "Parallel Thread Execution ISA Version 7.7".
76. Raihan, Md Aamir; Goli, Negar; Aamodt, Tor (2018). "Modeling Deep Learning Accelerator Enabled GPUs". arXiv:1811.08309 [cs.MS].
77. "NVIDIA Ada Lovelace Architecture".
78. shape x converted operand size, e.g. 2 tensor cores x 4x4x4xFP16/cycle = 256 Bytes/cycle
79. = product first 3 table rows
80. = product of previous 2 table rows; shape: e.g. 8x8x4xFP16 = 512 Bytes
81. Jia, Zhe; Maggioni, Marco; Smith, Jeffrey; Daniele Paolo Scarpazza (2019). "Dissecting the NVidia Turing T4 GPU via Microbenchmarking". arXiv:1903.07486 [cs.DC].
82. 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.
83. Jia, Zhe; Maggioni, Marco; Smith, Jeffrey; Daniele Paolo Scarpazza (2019). "Dissecting the NVidia Turing T4 GPU via Microbenchmarking". arXiv:1903.07486 [cs.DC].
84. 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.
85. dependent on device
86. "Tegra X1". 9 January 2015.
87. NVIDIA H100 Tensor Core GPU Architecture
88. H.1. Features and Technical Specifications – Table 14. Technical Specifications per Compute Capability
89. NVIDIA Hopper Architecture In-Depth
90. can only execute 160 integer instructions according to programming guide
91. 128 according to [1]. 64 from FP32 + 64 separate units?
92. 64 by FP32 cores and 64 by flexible FP32/INT cores.
93. "CUDA C++ Programming Guide".
94. 32 FP32 lanes combine to 16 FP64 lanes. Maybe lower depending on model.
95. only supported by 16 FP32 lanes, they combine to 4 FP64 lanes
96. depending on model
97. Effective speed, probably over FP32 ports. No description of actual FP64 cores.
98. Can also be used for integer additions and comparisons
99. 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.
100. Durant, Luke; Giroux, Olivier; Harris, Mark; Stam, Nick (May 10, 2017). "Inside Volta: The World's Most Advanced Data Center GPU". Nvidia developer blog.
101. The schedulers and dispatchers have dedicated execution units unlike with Fermi and Kepler.
102. Dispatching can overlap concurrently, if it takes more than one cycle (when there are less execution units than 32/SM Partition)
103. Can dual issue MAD pipe and SFU pipe
104. 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.
105. shared memory only, no data cache
106. shared memory separate, but L1 includes texture cache
107. "H.6.1. Architecture". docs.nvidia.com. Retrieved 2019-05-13.
108. "Demystifying GPU Microarchitecture through Microbenchmarking" (PDF).
109. Jia, Zhe; Maggioni, Marco; Staiger, Benjamin; Scarpazza, Daniele P. (2018). "Dissecting the NVIDIA Volta GPU Architecture via Microbenchmarking". arXiv:1804.06826 [cs.DC].
110. "Tegra X1". 9 January 2015.
111. Jia, Zhe; Maggioni, Marco; Smith, Jeffrey; Daniele Paolo Scarpazza (2019). "Dissecting the NVidia Turing T4 GPU via Microbenchmarking". arXiv:1903.07486 [cs.DC].
112. "Dissecting the Ampere GPU Architecture through Microbenchmarking".
113. 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
114. Jia, Zhe; Maggioni, Marco; Staiger, Benjamin; Scarpazza, Daniele P. (2018). "Dissecting the NVIDIA Volta GPU Architecture via Microbenchmarking". arXiv:1804.06826 [cs.DC].
115. "asfermi Opcode". GitHub.
116. for access with texture engine only
117. 25% disabled on RTX 4090
118. "I.7. Compute Capability 8.x". docs.nvidia.com. Retrieved 2022-10-12.
119. "Appendix F. Features and Technical Specifications" (PDF). (3.2 MiB), page 148 of 175 (Version 5.0 October 2012).
120. "nVidia CUDA Bioinformatics: BarraCUDA". BioCentric. 2019-07-19. Retrieved 2019-10-15.
121. "Part V: Physics Simulation". NVIDIA Developer. Retrieved 2020-09-11.
122. "oneAPI Programming Model". oneAPI.io. Retrieved 2024-07-27.
123. "Specifications | oneAPI". oneAPI.io. Retrieved 2024-07-27.
124. "oneAPI Specification — oneAPI Specification 1.3-rev-1 documentation". oneapi-spec.uxlfoundation.org. Retrieved 2024-07-27.
125. "Exclusive: Behind the plot to break Nvidia's grip on AI by targeting software". Reuters. Retrieved 2024-04-05.
126. "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.

External links

• Official website