stringtranslate.com

CUDA

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 luego Nvidia abandonó el uso común del acrónimo y ahora rara vez lo expande. [8]

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:

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. [9]

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. [10] 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 , [11] DirectCompute de Microsoft , OpenGL Compute Shader y C++ AMP . [12] 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. [13] [14] [15] [16] [17]

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, [18] que reemplaza a la versión beta lanzada el 14 de febrero de 2008. [19] 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):

CUDA 8.0 viene con estos otros componentes de software:

CUDA 9.0–9.2 viene con estos otros componentes:

CUDA 10 viene con estos otros componentes:

CUDA 11.0–11.8 viene con estos otros componentes: [20] [21] [22] [23]

Ventajas

CUDA tiene varias ventajas sobre el cálculo tradicional de propósito general en GPU (GPGPU) utilizando API de gráficos:

Limitaciones

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 . [36]

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 . [37]

 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: [38]

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

[58]

Tipos de datos

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

Núcleos tensoriales

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

[75] [76] [77] [78]

Especificaciones técnicas

[89]

[90]

Arquitectura multiprocesador

[119]

Para obtener más información, lea la guía de programación Nvidia CUDA. [120]

Usos actuales y futuros de la arquitectura CUDA

Comparación con la competencia

CUDA compite con otras pilas de computación de GPU: Intel OneAPI y AMD ROCm .

Mientras que CUDA de Nvidia es de código cerrado, OneAPI de Intel y ROCm de AMD son de código abierto.

API de Intel One

oneAPI es una iniciativa basada en estándares abiertos, creada para apoyar el desarrollo de software para múltiples arquitecturas de hardware. [123] Las bibliotecas oneAPI deben implementar especificaciones abiertas que son discutidas públicamente por los Grupos de Interés Especial, ofreciendo la posibilidad a cualquier desarrollador u organización de implementar sus propias versiones de las bibliotecas oneAPI. [124] [125]

Originalmente fabricado por Intel, otros adoptantes de hardware incluyen a Fujitsu y Huawei.

Fundación de Aceleración Unificada (UXL)

Unified Acceleration Foundation (UXL) es un nuevo consorcio tecnológico que trabaja en la continuación de la iniciativa OneAPI, con el objetivo de crear un nuevo ecosistema de software acelerador de estándares abiertos, estándares abiertos relacionados y proyectos de especificación a través de grupos de trabajo y grupos de interés especial (SIG). El objetivo es ofrecer alternativas abiertas a CUDA de Nvidia. Las principales empresas detrás de él son Intel, Google, ARM, Qualcomm, Samsung, Imagination y VMware. [126]

ROCM de AMD

ROCm [127] es una pila de software de código abierto para la programación de unidades de procesamiento gráfico (GPU) de Advanced Micro Devices (AMD).

Véase también

Referencias

  1. ^ ab Shah, Agam. "Nvidia no está totalmente en contra de que terceros fabriquen chips CUDA". www.theregister.com . Consultado el 25 de abril de 2024 .
  2. ^ Nvidia. "¿Qué es CUDA?". Nvidia . Consultado el 21 de marzo de 2024 .
  3. ^ ab Abi-Chahla, Fedy (18 de junio de 2008). "CUDA de Nvidia: ¿el fin de la CPU?". Tom's Hardware . Consultado el 17 de mayo de 2015 .
  4. ^ Zunitch, Peter (24 de enero de 2018). "CUDA vs. OpenCL vs. OpenGL". Videomaker . Consultado el 16 de septiembre de 2018 .
  5. ^ "OpenCL". NVIDIA Developer . 2013-04-24 . Consultado el 2019-11-04 .
  6. ^ "Página de inicio de Nvidia CUDA". 18 de julio de 2017.
  7. ^ Shimpi, Anand Lal; Wilson, Derek (8 de noviembre de 2006). "GeForce 8800 (G80) de Nvidia: GPU rediseñadas para DirectX 10". AnandTech . Consultado el 16 de mayo de 2015 .
  8. ^ "Introducción: documentación de nsight-visual-studio-edition 12.6". docs.nvidia.com . Consultado el 10 de octubre de 2024 .
  9. ^ Witt, Stephen (27 de noviembre de 2023). «Cómo la Nvidia de Jensen Huang está impulsando la revolución de la IA». The New Yorker . ISSN  0028-792X . Consultado el 10 de diciembre de 2023 .
  10. ^ "Compilador CUDA LLVM". 7 de mayo de 2012.
  11. ^ Primera demostración de OpenCL en una GPU en YouTube
  12. ^ Demostración de DirectCompute Ocean ejecutándose en una GPU compatible con CUDA de Nvidia en YouTube
  13. ^ Vasiliadis, Giorgos; Antonatos, Spiros; Polychronakis, Michalis; Markatos, Evangelos P.; Ioannidis, Sotiris (septiembre de 2008). "Gnort: detección de intrusiones en redes de alto rendimiento mediante procesadores gráficos" (PDF) . Avances recientes en detección de intrusiones . Apuntes de clase en informática. Vol. 5230. págs. 116–134. doi :10.1007/978-3-540-87403-4_7. ISBN 978-3-540-87402-7.
  14. ^ Schatz, Michael C.; Trapnell, Cole; Delcher, Arthur L.; Varshney, Amitabh (2007). "Alineamiento de secuencias de alto rendimiento utilizando unidades de procesamiento gráfico". BMC Bioinformatics . 8 : 474. doi : 10.1186/1471-2105-8-474 . PMC 2222658 . PMID  18070356. 
  15. ^ Manavski, Svetlin A.; Giorgio, Valle (2008). "Tarjetas GPU compatibles con CUDA como aceleradores de hardware eficientes para la alineación de secuencias Smith-Waterman". BMC Bioinformatics . 10 (Suppl 2): ​​S10. doi : 10.1186/1471-2105-9-S2-S10 . PMC 2323659 . PMID  18387198. 
  16. ^ "Pyrit – Código de Google".
  17. ^ "Utilice su GPU Nvidia para realizar cálculos científicos". BOINC. 18 de diciembre de 2008. Archivado desde el original el 28 de diciembre de 2008. Consultado el 8 de agosto de 2017 .
  18. ^ "Kit de desarrollo de software CUDA de Nvidia (CUDA SDK): notas de la versión 2.0 para MAC OS X". Archivado desde el original el 6 de enero de 2009.
  19. ^ "CUDA 1.1 – Ahora en Mac OS X". 14 de febrero de 2008. Archivado desde el original el 22 de noviembre de 2008.
  20. ^ "Se revelan las características de CUDA 11". 14 de mayo de 2020.
  21. ^ "CUDA Toolkit 11.1 incorpora compatibilidad con GPU GeForce RTX 30 Series y Quadro RTX Series". 23 de septiembre de 2020.
  22. ^ "Mejora de la asignación de memoria con las nuevas funciones de NVIDIA CUDA 11.2". 16 de diciembre de 2020.
  23. ^ "Explorando las nuevas características de CUDA 11.3". 16 de abril de 2021.
  24. ^ Silberstein, Mark; Schuster, Assaf ; Geiger, Dan; Patney, Anjul; Owens, John D. (2008). "Cálculo eficiente de productos de suma en GPU mediante caché administrada por software" (PDF) . Actas de la 22.ª conferencia internacional anual sobre supercomputación: ICS '08 (PDF) . Actas de la 22.ª conferencia internacional anual sobre supercomputación: ICS '08. págs. 309–318. doi :10.1145/1375527.1375572. ISBN 978-1-60558-158-3.
  25. ^ "CUDA C Programming Guide v8.0" (PDF) . nVidia Developer Zone . Enero de 2017. pág. 19 . Consultado el 22 de marzo de 2017 .
  26. ^ "NVCC fuerza la compilación de archivos .cu en C++". 29 de noviembre de 2011.
  27. ^ Whitehead, Nathan; Fit-Florea, Alex. "Precisión y rendimiento: compatibilidad con punto flotante e IEEE 754 para GPU Nvidia" (PDF) . Nvidia . Consultado el 18 de noviembre de 2014 .
  28. ^ "Productos compatibles con CUDA". Zona CUDA . Nvidia Corporation . Consultado el 3 de noviembre de 2008 .
  29. ^ "Proyecto Coriander: compilar códigos CUDA en OpenCL y ejecutarlos en cualquier lugar". Phoronix.
  30. ^ Perkins, Hugh (2017). "cuda-on-cl" (PDF) . IWOCL . Consultado el 8 de agosto de 2017 .
  31. ^ "hughperkins/coriander: Generar código NVIDIA® CUDA™ para dispositivos OpenCL™ 1.2". GitHub. 6 de mayo de 2019.
  32. ^ "Documentación CU2CL". chrec.cs.vt.edu .
  33. ^ "GitHub – vosen/ZLUDA". GitHub .
  34. ^ Larabel, Michael (12 de febrero de 2024), "AMD financió silenciosamente una implementación de CUDA basada en ROCm: ahora es de código abierto", Phoronix , consultado el 12 de febrero de 2024
  35. ^ "GitHub – chip-spv/chipStar". GitHub .
  36. ^ "PyCUDA".
  37. ^ "pycublas". Archivado desde el original el 20 de abril de 2009. Consultado el 8 de agosto de 2017 .
  38. ^ "CuPy" . Consultado el 8 de enero de 2020 .
  39. ^ "Guía de programación de NVIDIA CUDA. Versión 1.0" (PDF) . 23 de junio de 2007.
  40. ^ "Guía de programación NVIDIA CUDA. Versión 2.1" (PDF) . 8 de diciembre de 2008.
  41. ^ "Guía de programación de NVIDIA CUDA. Versión 2.2" (PDF) . 2 de abril de 2009.
  42. ^ "Guía de programación de NVIDIA CUDA. Versión 2.2.1" (PDF) . 26 de mayo de 2009.
  43. ^ "Guía de programación de NVIDIA CUDA. Versión 2.3.1" (PDF) . 26 de agosto de 2009.
  44. ^ "Guía de programación NVIDIA CUDA. Versión 3.0" (PDF) . 20 de febrero de 2010.
  45. ^ "Guía de programación NVIDIA CUDA C. Versión 3.1.1" (PDF) . 21 de julio de 2010.
  46. ^ "Guía de programación NVIDIA CUDA C. Versión 3.2" (PDF) . 9 de noviembre de 2010.
  47. ^ "Notas de la versión de CUDA 11.0". NVIDIA Developer .
  48. ^ "Notas de la versión de CUDA 11.1". NVIDIA Developer .
  49. ^ "Notas de la versión de CUDA 11.5". NVIDIA Developer .
  50. ^ "Notas de la versión de CUDA 11.8". NVIDIA Developer .
  51. ^ "Especificaciones de la NVIDIA Quadro NVS 420". Base de datos de GPU de TechPowerUp . 25 de agosto de 2023.
  52. ^ Larabel, Michael (29 de marzo de 2017). "NVIDIA lanza compatibilidad con GPU Tegra X2 en Nouveau". Phoronix . Consultado el 8 de agosto de 2017 .
  53. ^ Especificaciones de Nvidia Xavier en TechPowerUp (preliminares)
  54. ^ "Bienvenido: documentación de Jetson LinuxDeveloper Guide 34.1".
  55. ^ "NVIDIA ofrece compatibilidad con GPU Volta de código abierto para su SoC Xavier".
  56. ^ "Arquitectura NVIDIA Ada Lovelace".
  57. ^ Análisis de la arquitectura de la GPU Turing mediante microbenchmarking
  58. ^ "H.1. Características y especificaciones técnicas: Tabla 13. Compatibilidad de funciones por capacidad de cómputo". docs.nvidia.com . Consultado el 23 de septiembre de 2020 .
  59. ^ "Guía de programación CUDA C++".
  60. ^ Fusionar-Multiplicar-Agregar, realmente ejecutado, Matriz Densa
  61. ^ como SASS desde 7.5, como PTX desde 8.0
  62. ^ "Resumen técnico. Serie NVIDIA Jetson AGX Orin" (PDF) . nvidia.com . Consultado el 5 de septiembre de 2023 .
  63. ^ "Arquitectura de la GPU NVIDIA Ampere GA102" (PDF) . nvidia.com . Consultado el 5 de septiembre de 2023 .
  64. ^ Luo, Weile; Fan, Ruibo; Li, Zeyu; Du, Dayou; Wang, Qiang; Chu, Xiaowen (2024). "Evaluación comparativa y análisis de la arquitectura de GPU Nvidia Hopper". arXiv : 2402.13499v1 [cs.AR].
  65. ^ "Ficha técnica NVIDIA A40" (PDF) . nvidia.com . Consultado el 27 de abril de 2024 .
  66. ^ "ARQUITECTURA DE LA GPU NVIDIA AMPERE GA102" (PDF) . 27 de abril de 2024.
  67. ^ "Ficha técnica NVIDIA L40" (PDF) . 27 de abril de 2024.
  68. ^ En los documentos técnicos, los diagramas cúbicos de Tensor Core representan el ancho de la unidad de producto escalar en la altura (4 FP16 para Volta y Turing, 8 FP16 para A100, 4 FP16 para GA102, 16 FP16 para GH100). Las otras dos dimensiones representan la cantidad de unidades de producto escalar (4x4 = 16 para Volta y Turing, 8x4 = 32 para Ampere y Hopper). Los bloques grises resultantes son las operaciones FMA de FP16 por ciclo. Pascal sin Tensor Core solo se muestra para comparación de velocidad, al igual que Volta V100 con tipos de datos que no son FP16.
  69. ^ "Informe técnico sobre la arquitectura Turing de NVIDIA" (PDF) . nvidia.com . Consultado el 5 de septiembre de 2023 .
  70. ^ "GPU NVIDIA Tensor Core" (PDF) . nvidia.com . Consultado el 5 de septiembre de 2023 .
  71. ^ "Arquitectura NVIDIA Hopper en profundidad". 22 de marzo de 2022.
  72. ^ forma x tamaño del operando convertido, p. ej. 2 núcleos tensores x 4x4x4xFP16/ciclo = 256 bytes/ciclo
  73. ^ = producto de las primeras 3 filas de la tabla
  74. ^ = producto de las 2 filas de la tabla anteriores; forma: p. ej. 8x8x4xFP16 = 512 bytes
  75. ^ Sun, Wei; Li, Ang; Geng, Tong; Stuijk, Sander; Corporaal, Henk (2023). "Disección de núcleos tensoriales mediante microbenchmarks: latencia, rendimiento y comportamientos numéricos". IEEE Transactions on Parallel and Distributed Systems . 34 (1): 246–261. arXiv : 2206.02874 . doi :10.1109/tpds.2022.3217824. S2CID  249431357.
  76. ^ "Ejecución de subprocesos paralelos ISA versión 7.7".
  77. ^ Raihan, Md Aamir; Goli, Negar; Aamodt, Tor (2018). "Modelado de GPU con acelerador de aprendizaje profundo habilitado". arXiv : 1811.08309 [cs.MS].
  78. ^ "Arquitectura NVIDIA Ada Lovelace".
  79. ^ forma x tamaño del operando convertido, p. ej. 2 núcleos tensores x 4x4x4xFP16/ciclo = 256 bytes/ciclo
  80. ^ = producto de las primeras 3 filas de la tabla
  81. ^ = producto de las 2 filas de la tabla anteriores; forma: p. ej. 8x8x4xFP16 = 512 bytes
  82. ^ Jia, Zhe; Maggioni, Marco; Smith, Jeffrey; Daniele Paolo Scarpazza (2019). "Disección de la GPU NVidia Turing T4 mediante microbenchmarking". arXiv : 1903.07486 [cs.DC].
  83. ^ Burgess, John (2019). "RTX ON – La GPU NVIDIA TURING". Simposio IEEE Hot Chips 31 de 2019 (HCS) . págs. 1–27. doi :10.1109/HOTCHIPS.2019.8875651. ISBN 978-1-7281-2089-8.S2CID204822166  .​
  84. ^ Jia, Zhe; Maggioni, Marco; Smith, Jeffrey; Daniele Paolo Scarpazza (2019). "Disección de la GPU NVidia Turing T4 mediante microbenchmarking". arXiv : 1903.07486 [cs.DC].
  85. ^ Burgess, John (2019). "RTX ON – La GPU NVIDIA TURING". Simposio IEEE Hot Chips 31 de 2019 (HCS) . págs. 1–27. doi :10.1109/HOTCHIPS.2019.8875651. ISBN 978-1-7281-2089-8.S2CID204822166  .​
  86. ^ depende del dispositivo
  87. ^ "Tegra X1". 9 de enero de 2015.
  88. ^ Arquitectura de GPU NVIDIA H100 Tensor Core
  89. ^ H.1. Características y especificaciones técnicas – Tabla 14. Especificaciones técnicas por capacidad de cómputo
  90. ^ Arquitectura NVIDIA Hopper en profundidad
  91. ^ solo puede ejecutar 160 instrucciones enteras según la guía de programación
  92. ^ 128 según [1]. 64 de FP32 + 64 unidades separadas?
  93. ^ 64 por núcleos FP32 y 64 por núcleos FP32/INT flexibles.
  94. ^ "Guía de programación CUDA C++".
  95. ^ 32 carriles FP32 se combinan para formar 16 carriles FP64. Puede ser menor según el modelo.
  96. ^ solo es compatible con 16 carriles FP32, se combinan para formar 4 carriles FP64
  97. ^ abcdef depende del modelo
  98. ^ Velocidad efectiva, probablemente sobre puertos FP32. No hay descripción de núcleos FP64 reales.
  99. ^ También se puede utilizar para adiciones y comparaciones de números enteros.
  100. ^ 2 ciclos de reloj/instrucción para cada partición SM Burgess, John (2019). "RTX ON – La GPU NVIDIA TURING". Simposio IEEE Hot Chips 31 de 2019 (HCS) . págs. 1–27. doi :10.1109/HOTCHIPS.2019.8875651. ISBN 978-1-7281-2089-8.S2CID204822166  .​
  101. ^ Durant, Luke; Giroux, Olivier; Harris, Mark; Stam, Nick (10 de mayo de 2017). "Dentro de Volta: la GPU para centros de datos más avanzada del mundo". Blog para desarrolladores de Nvidia .
  102. ^ Los programadores y despachadores tienen unidades de ejecución dedicadas, a diferencia de Fermi y Kepler.
  103. ^ El envío puede superponerse simultáneamente, si toma más de un ciclo (cuando hay menos unidades de ejecución que 32/Partición SM)
  104. ^ ¿ Se pueden emitir simultáneamente tuberías MAD y SFU?
  105. ^ No más de un planificador puede emitir 2 instrucciones a la vez. El primer planificador está a cargo de los warps con ID impares. El segundo planificador está a cargo de los warps con ID pares.
  106. ^ Solo memoria compartida, sin caché de datos
  107. ^ abcdef memoria compartida separada, pero L1 incluye caché de textura
  108. ^ "H.6.1. Arquitectura". docs.nvidia.com . Consultado el 13 de mayo de 2019 .
  109. ^ "Desmitificando la microarquitectura de la GPU a través de microbenchmarking" (PDF) .
  110. ^ Jia, Zhe; Maggioni, Marco; Staiger, Benjamín; Scarpazza, Daniele P. (2018). "Disección de la arquitectura de la GPU NVIDIA Volta mediante microbenchmarking". arXiv : 1804.06826 [cs.DC].
  111. ^ "Tegra X1". 9 de enero de 2015.
  112. ^ Jia, Zhe; Maggioni, Marco; Smith, Jeffrey; Daniele Paolo Scarpazza (2019). "Disección de la GPU NVidia Turing T4 mediante microbenchmarking". arXiv : 1903.07486 [cs.DC].
  113. ^ "Disección de la arquitectura de la GPU Ampere a través de microbenchmarking".
  114. ^ Tenga en cuenta que Jia, Zhe; Maggioni, Marco; Smith, Jeffrey; Daniele Paolo Scarpazza (2019). "Disección de la GPU NVidia Turing T4 mediante microbenchmarking". arXiv : 1903.07486 [cs.DC].no está de acuerdo y afirma que hay 2 KiB de caché de instrucciones L0 por partición SM y 16 KiB de caché de instrucciones L1 por SM
  115. ^ Jia, Zhe; Maggioni, Marco; Staiger, Benjamín; Scarpazza, Daniele P. (2018). "Disección de la arquitectura de la GPU NVIDIA Volta mediante microbenchmarking". arXiv : 1804.06826 [cs.DC].
  116. ^ "Código de operación de asfermi". GitHub .
  117. ^ ab solo para acceso con motor de textura
  118. ^ 25% deshabilitado en RTX 4090
  119. ^ "I.7. Compute Capability 8.x". docs.nvidia.com . Consultado el 12 de octubre de 2022 .
  120. ^ "Apéndice F. Características y especificaciones técnicas" (PDF) . (3,2 MiB) , página 148 de 175 (Versión 5.0 octubre de 2012).
  121. ^ "Bioinformática CUDA de nVidia: BarraCUDA". BioCentric . 19 de julio de 2019 . Consultado el 15 de octubre de 2019 .
  122. ^ "Parte V: Simulación de física". NVIDIA Developer . Consultado el 11 de septiembre de 2020 .
  123. ^ "Modelo de programación oneAPI". oneAPI.io . Consultado el 27 de julio de 2024 .
  124. ^ "Especificaciones | oneAPI". oneAPI.io . Consultado el 27 de julio de 2024 .
  125. ^ "Especificación oneAPI — Documentación de la especificación oneAPI 1.3-rev-1". oneapi-spec.uxlfoundation.org . Consultado el 27 de julio de 2024 .
  126. ^ "Exclusiva: Detrás de la trama para romper el control de Nvidia sobre la IA atacando al software". Reuters . Consultado el 5 de abril de 2024 .
  127. ^ "Pregunta: ¿Qué significa ROCm? · Problema n.° 1628 · RadeonOpenCompute/ROCm". Github.com . Consultado el 18 de enero de 2022 .

Lectura adicional

Enlaces externos