Whitepaper

TM
Arquitectura de cómputo CUDA
de próxima generación de NVIDIA:

Fermi
TM
Table of Contents
Una breve historia de la computación GPU .................................................................................................. 3
La arquitectura G80 .................................................................................................................................. 4
La arquitectura de computación y gráficos CUDA de próxima generación de NVIDIA, cuyo nombre en
código es "Fermi" ...................................................................................................................................... 4
Una actualización rápida en CUDA .......................................................................................................... 6
Ejecución de hardware .......................................................................................................................... 7
Una visión general de la arquitectura Fermi ................................................................................................. 7
Multiprocesador de streaming de tercera generación .............................................................................. 8
512 núcleos CUDA de alto rendimiento ................................................................................................ 8
16 unidades de carga / almacenamiento .............................................................................................. 8
Cuatro unidades de funciones especiales ............................................................................................ 9
Diseñado para doble precisión ............................................................................................................. 9
Programador Dual Warp ..................................................................................................................... 10
64 KB de memoria compartida configurable y caché L1 .................................................................... 10
Table de resume ................................................................................................................................ 11
Ejecución de subprocesos paralelos de segunda generación ISA ......................................................... 11
El espacio de direcciones unificadas habilita el soporte completo de C ++ ....................................... 12
Optimizado para OpenCL y DirectCompute ....................................................................................... 13
Precisión de punto flotante IEEE de 32 bits ........................................................................................ 13
Mejora del rendimiento condicional a través de la predicción ............................................................ 14
Innovaciones del subsistema de memoria .............................................................................................. 15
NVIDIA Parallel DataCacheTM con L1 configurable y Unified L2 Cache ........................................... 15
Primera GPU con soporte de memoria ECC ...................................................................................... 17
Operaciones rápidas de memoria atómica ......................................................................................... 17
Programador de hilos GigaThreadTM ...................................................................................................... 18
Cambio de contexto de aplicación más rápido 10x ............................................................................ 18
Ejecución concurrente de Kernel ........................................................................................................ 18
Presentamos NVIDIA Nexus ....................................................................................................................... 19
Conclusion................................................................................................................................................... 20
 Una breve historia de la computación GPU
La unidad de procesamiento de gráficos (GPU), inventada por primera vez por NVIDIA en
1999, es el procesador paralelo más generalizado hasta la fecha. Alimentada por el insaciable
deseo de gráficos en tiempo real realistas, la GPU se ha convertido en un procesador con un
rendimiento y programabilidad de punto flotante sin precedentes; Las GPU de hoy superan
ampliamente a las CPU en rendimiento aritmético y ancho de banda de memoria, lo que las
convierte en el procesador ideal para acelerar una variedad de aplicaciones paralelas de
datos.

Los esfuerzos para explotar la GPU para aplicaciones no gráficas han estado en marcha
desde 2003. Al usar lenguajes de sombreado de alto nivel como DirectX, OpenGL y Cg,
varios algoritmos de datos paralelos se han incorporado a la GPU. Los problemas como el
plegamiento de proteínas, los precios de las opciones sobre acciones, las consultas de SQL y
la reconstrucción de MRI lograron notables mejoras de rendimiento en la GPU. Estos
primeros esfuerzos que utilizaron API de gráficos para la computación de propósito general
se conocieron como programas GPGPU.
Si bien el modelo GPGPU demostró grandes aceleraciones, enfrentó varios inconvenientes. Primero,
se requería que el programador poseyera un conocimiento íntimo de las API de gráficos y la
arquitectura de GPU. En segundo lugar, los problemas tenían que expresarse en términos de
coordenadas de vértice, texturas y programas de sombreado, lo que aumentaba enormemente la
complejidad del programa. En tercer lugar, las funciones de programación básicas, como las lecturas
aleatorias y las escrituras en memoria, no eran compatibles, lo que restringía en gran medida el
modelo de programación. Por último, la falta de soporte de doble precisión (hasta hace poco)
significaba que algunas aplicaciones científicas no podían ejecutarse en la GPU.

Para abordar estos problemas, NVIDIA introdujo dos tecnologías clave: los gráficos unificados
G80 y la arquitectura informática (introducidas por primera vez en las GPU GeForce 8800®,
Quadro FX 5600® y Tesla C870®), y CUDA, una arquitectura de software y hardware que
permitió a la GPU. Para ser programado con una variedad de lenguajes de programación de
alto nivel. Juntas, estas dos tecnologías representan una nueva forma de usar la GPU.. En
lugar de programar unidades gráficas dedicadas con API de gráficos, el programador ahora
podría escribir programas en C con extensiones CUDA y apuntar a un procesador masivo
paralelo de propósito general. Llamamos a esta nueva forma de programación de GPU "GPU
Computing": significaba un soporte de aplicaciones más amplio, un soporte de lenguaje de
programación más amplio y una clara separación del modelo de programación "GPGPU"
temprano.

Arquitectura G80
GeForce 8800 de NVIDIA fue el producto que dio origen al nuevo modelo de GPU Computing.
Presentado en noviembre de 2006, la GeForce 8800 basada en G80 trajo varias innovaciones clave
a la GPU Computing:

3
 • G80 fue la primera GPU que admitió C, permitiendo a los programadores usar el poder
de la GPU sin tener que aprender un nuevo lenguaje de programación.
G80 fue la primera GPU en reemplazar las tuberías de vértices y píxeles
independientes con un procesador único y unificado que ejecutaba programas de
vértice, geometría, píxeles y computación.
G80 fue la primera GPU en utilizar un procesador de subprocesos escalares, eliminando
la necesidad de que los programadores gestionen manualmente los registros vectoriales.
G80 introdujo el modelo de ejecución de múltiples hilos de una sola instrucción (SIMT)
donde múltiples hilos independientes se ejecutan simultáneamente utilizando una sola
instrucción.
• G80 introdujo la memoria compartida y la sincronización de barrera para la
comunicación entre subprocesos.
En junio de 2008, NVIDIA introdujo una revisión importante de la arquitectura del G80. La
arquitectura unificada de segunda generación: GT200 (introducida por primera vez en las GPU
GeForce GTX 280, Quadro FX 5800 y Tesla T10) aumentó el número de núcleos de procesador de
transmisión (posteriormente denominados núcleos CUDA) de 128 a 240. Cada archivo de registro de
procesador se duplicó en tamaño, permitiendo que un mayor número de subprocesos se ejecuten en
un chip en un momento dado. Se agregó la fusión del acceso a la memoria del hardware para
mejorar la eficiencia del acceso a la memoria. También se agregó soporte de punto flotante de doble
precisión para satisfacer las necesidades de las aplicaciones científicas y de computación de alto
rendimiento (HPC).

Al diseñar cada GPU de nueva generación, siempre ha sido la filosofía de NVIDIA mejorar el
rendimiento de la aplicación existente y la capacidad de programación de la GPU; Si bien el
rendimiento más rápido de la aplicación brinda beneficios inmediatos, es el avance implacable de la
GPU en la capacidad de programación lo que le ha permitido evolucionar hacia el procesador
paralelo más versátil de nuestro tiempo. Fue con esta mentalidad que nos dispusimos a desarrollar
el sucesor de la arquitectura GT200.

La próxima generación de NVIDIA

Arquitectura de computación y gráficos de CUDA, con
nombre en código “Fermi”
La arquitectura Fermi es el salto más significativo en la arquitectura GPU desde el G80 original. G80
fue nuestra visión inicial de cómo debería ser un procesador paralelo de computación y gráficos
unificados. GT200 extendió el rendimiento y la funcionalidad de G80. Con Fermi, hemos tomado
todo lo que hemos aprendido de los dos procesadores anteriores y todas las aplicaciones que se
escribieron para ellos, y hemos empleado un enfoque completamente nuevo para diseñar y crear la
primera GPU computacional del mundo. Cuando comenzamos a sentar las bases para Fermi,
reunimos una amplia cantidad de comentarios de los usuarios sobre la computación de GPU desde
la introducción de G80 y GT200, y nos enfocamos en las siguientes áreas clave para mejorar:

4
 Mejore el rendimiento de doble precisión: mientras que el rendimiento de punto
flotante de precisión simple fue del orden de diez veces el rendimiento de las CPU de
escritorio, algunas aplicaciones de computación de la GPU también deseaban un
rendimiento de doble precisión.
 Compatibilidad con ECC: ECC permite a los usuarios de computación de la GPU
implementar con seguridad un gran número de GPU en las instalaciones del centro de datos y
también garantizar que las aplicaciones sensibles a los datos, como las imágenes médicas y los
precios de las opciones financieras, estén protegidas de los errores de memoria.
 • Jerarquía de caché verdadera: algunos algoritmos paralelos no pudieron usar la
memoria compartida de la GPU, y los usuarios solicitaron una arquitectura de caché
verdadera para ayudarlos.
• Más memoria compartida: muchos programadores de CUDA solicitaron más de 16 KB
de memoria compartida SM para acelerar sus aplicaciones.
 Cambio de contexto más rápido: los usuarios solicitaron cambios de contexto más
rápidos entre programas de aplicación y gráficos más rápidos y una interoperación
informática.
 Operaciones atómicas más rápidas: los usuarios solicitaron operaciones atómicas de
lectura-modificación-escritura más rápidas para sus algoritmos paralelos.

Con estas solicitudes en mente, el equipo de Fermi diseñó un procesador que aumenta
enormemente la potencia bruta de cómputo y, a través de innovaciones arquitectónicas, también
ofrece una capacidad de programación y eficiencia de cómputo considerablemente mayores. Los
aspectos más destacados de la arquitectura de Fermi son:

- Multiprocesador de transmisión de tercera generación (SM)

32 núcleos CUDA por SM, 4x sobre GT200
8 veces el rendimiento máximo de punto flotante de doble precisión sobre GT200Dual Warp
Scheduler programa y envía simultáneamente instrucciones de dos warp independientes.
64 KB de RAM con una partición configurable de memoria compartida y caché L1
- Ejecución de subprocesos paralelos de segunda generación ISA
Espacio de direcciones unificado con soporte completo de C ++
Optimizado para OpenCL y DirectCompute
Completa IEEE 754-2008 de 32 bits y 64 bits de precisión
Ruta completa de 32 bits con extensiones de 64 bits
Instrucciones de acceso a la memoria para admitir la transición al direccionamiento de 64 bits.
Mejora del rendimiento a través de la predicción
- Subsistema de memoria mejorado
Jerarquía NVIDIA Parallel DataCacheTM con cachés configurables L1 y Unified L2
Primera GPU con soporte de memoria ECC
Gran rendimiento de la operación de memoria atómica
- Motor NVIDIA GigaThreadTM
Cambio de contexto de aplicación 10 veces más rápido
Ejecución concurrente del kernel
Ejecución de bloque de hilo fuera de orden
motores de transferencia de memoria dual superpuestos

5
-Una actualización rápida en CUDA
CUDA es la arquitectura de hardware y software que permite a las GPU NVIDIA ejecutar programas
escritos con C, C ++, Fortran, OpenCL, DirectCompute y otros idiomas. Un programa CUDA llama
kernels paralelos. Un kernel se ejecuta en paralelo a través de un conjunto de hilos paralelos. El
programador o compilador organiza estos hilos en bloques de hilos y cuadrículas de bloques de
hilos. La GPU crea una instancia de un programa de kernel en una cuadrícula de bloques de hilos
paralelos. Cada subproceso dentro de un bloque de subprocesos ejecuta una instancia del kernel y
tiene una ID de subproceso dentro de su bloque de subprocesos, contador de programas, registros,
memoria privada por subprocesos, entradas y resultados de salida.
Un bloque de subprocesos es
un conjunto de subprocesos
que se ejecutan
simultáneamente que pueden
cooperar entre sí mediante la
sincronización de barreras y la
memoria compartida. Un bloque
de hilo tiene un ID de bloque
dentro de su cuadrícula.
Una cuadrícula es una matriz de
bloques de hilos que ejecutan el
mismo kernel, leen las entradas de la
memoria global, escriben los
resultados en la memoria global y
sincronizan entre las llamadas
dependientes del kernel. En el modelo
de programación paralela de CUDA,
cada subproceso tiene un espacio de
memoria privada por subproceso
utilizado para los derrames de
registros, llamadas a funciones y
variables de matriz automática C.
Cada bloque de subprocesos tiene un
espacio de memoria compartida por
bloque que se utiliza para la
comunicación entre subprocesos, el
intercambio de datos y el intercambio
de resultados en algoritmos paralelos.
CUDA Jerarquía de subprocesos, bloques y cuadrículas, con Las cuadrículas de bloques de
los correspondientes espacios privados, compartidos por subprocesos comparten los resultados
bloque, y espacios de memoria por aplicación en el espacio de la memoria global
correspondientes. después de la sincronización global de
todo el núcleo.

6
Ejecución de hardware
La jerarquía de hilos de CUDA se asigna a una jerarquía de procesadores en la GPU; una GPU
ejecuta una o más cuadrículas de kernel; un multiprocesador de transmisión (SM) ejecuta uno o más
bloques de subprocesos; y los núcleos CUDA y otras unidades de ejecución en los subprocesos de
ejecución SM. El SM ejecuta subprocesos en grupos de 32 subprocesos llamados una deformación.
Mientras que los programadores generalmente pueden ignorar la ejecución de deformación para la
corrección funcional y pensar en programar un subproceso, pueden mejorar considerablemente el
rendimiento al hacer que los subprocesos en una deformación ejecuten la misma ruta de código y
acceder a la memoria en las direcciones cercanas.

Una visión general de la arquitectura Fermi

La primera GPU basada en Fermi, implementada con 3.0 mil millones de transistores,
presenta hasta 512 núcleos CUDA. Un núcleo CUDA ejecuta una instrucción de punto
flotante o entero por reloj para un hilo. Los 512 núcleos CUDA están organizados en 16 SM
de 32 núcleos cada uno. La GPU tiene seis particiones de memoria de 64 bits, para una
interfaz de memoria de 384 bits, que admite hasta un total de 6 GB de memoria DRAM
GDDR5. Una interfaz de host conecta la GPU a la CPU a través de PCI-Express. El
programador global GigaThread distribuye bloques de subprocesos a los programadores de
subprocesos SM.

Los 16 SM de Fermi están posicionados alrededor de un caché L2 común. Cada SM es una franja
rectangular vertical que contiene una parte naranja (programador y envío), una parte verde
(unidades de ejecución) y partes azul claro (archivo de registro y caché L1).

7
 Instruction Cache
Multiprocesador de Warp Scheduler Warp Scheduler

streaming de tercera Dispatch Unit Dispatch Unit

generación
Register File (4096 x 32-bit)

La tercera generación de SM presenta varias

innovaciones arquitectónicas que lo convierten
no solo en el SM más potente que se haya
LD/ST
construido, sino también en el más programable Core Core Core Core
LD/ST
y eficiente. SFU
LD/ST
Core Core Core Core
LD/ST
512 núcleos CUDA de alto rendimiento
LD/ST
Core Core Core Core
Cada SM cuenta con 32 LD/ST

procesadores CUDA, un SFU

LD/ST
Dispatch Port
aumento de cuatro veces Core Core Core Core
LD/ST
sobre los diseños anteriores Operand Collector LD/ST
de SM. Cada procesador Core Core Core Core
LD/ST
CUDA tiene una unidad FP Unit INT Unit LD/ST SFU
lógica aritmética de enteros Core Core Core Core LD/ST
(ALU) y una unidad de punto
LD/ST
flotante (FPU) totalmente
canalizada. Resul Core Core Core Core LD/ST

SFU
Las GPU anteriores utilizaban la aritmética de punto LD/ST

Core Core Core Core

flotante IEEE 754-1985. La arquitectura Fermi LD/ST

implementa el nuevo estándar de punto flotante IEEE

754-2008, que proporciona la instrucción fusionada de
adición múltiple (FMA) para aritmética de precisión
simple y doble. FMA mejora sobre una instrucción de
adición múltiple (MAD) haciendo la multiplicación y la Interconnect Network
suma con un solo paso de redondeo final, sin pérdida de
precisión en la adición. FMA es más preciso que realizar
las operaciones por separado. GT200 implementado de
doble precisión FMA.
Fermi Streaming Multiprocessor (SM)

En GT200, la ALU entera estaba limitada a una precisión de 24 bits para operaciones múltiples;
como resultado, se requirieron secuencias de emulación de múltiples instrucciones para la aritmética
de enteros. En Fermi, el ALU entero de nuevo diseño admite una precisión total de 32 bits para
todas las instrucciones, de acuerdo con los requisitos del lenguaje de programación estándar. La
ALU entera también está optimizada para admitir de manera eficiente operaciones de precisión
extendida y de 64 bits. Se admiten varias instrucciones, que incluyen booleanos, desplazar, mover,
comparar, convertir, extracción de campo de bits, inserción de inversión de bits y conteo de
población.

16 unidades de carga / almacenamiento

Cada SM tiene 16 unidades de carga / almacenamiento, lo que permite calcular las direcciones de
origen y destino para dieciséis subprocesos por reloj. Las unidades de soporte cargan y almacenan
los datos en cada dirección en caché o DRAM.

8
Cuatro unidades de funciones especiales

Las Unidades de funciones especiales (SFSu) ejecutan instrucciones trascendentales como el seno,
el coseno, el recíproco y la raíz cuadrada. Cada SFU ejecuta una instrucción por hilo, por reloj; una
urdimbre ejecuta más de ocho relojes. La tubería de SFU se desacopla de la unidad de envío, lo que
permite que la unidad de envío emita a otras unidades de ejecución mientras la SFU está ocupada.

Diseñado para doble precisión

La aritmética de doble precisión está en el corazón de las aplicaciones de HPC, como el álgebra
lineal, la simulación numérica y la química cuántica. La arquitectura Fermi ha sido diseñada
específicamente para ofrecer un rendimiento sin precedentes en doble precisión; Se pueden realizar
hasta 16 operaciones de adición múltiple fusionadas de precisión doble por SM, por reloj, una
mejora dramática sobre la arquitectura GT200.

Rendimiento de la aplicación de doble precisión

450%

400%

350%

300% GT200
Architecture
250%
Fermi
200% Architecture
150%

100%

50%

0%
Double Precision Matrix Double Precision Tri-Diagonal
Multiply Solver

Las primeras evaluaciones de rendimiento muestran que Fermi se desempeña hasta 4.2 veces más
rápido que GT200 en aplicaciones de doble precisión.

9
Programador Dual Warp

El SM planifica hilos en grupos de 32 hilos paralelos llamados deformaciones. Cada SM cuenta

con dos programadores de deformación y dos unidades de despacho de instrucciones, lo que
permite emitir y ejecutar simultáneamente dos distorsiones. El programador de deformación
dual de Fermi selecciona dos deformaciones y emite una instrucción de cada deformación a un
grupo de dieciséis núcleos, dieciséis unidades de carga / almacenamiento o cuatro unidades
de suministro de energía. Debido a que las deformaciones se ejecutan de forma independiente,
el programador de Fermi no necesita verificar las dependencias dentro del flujo de
instrucciones. Utilizando este elegante modelo de doble emisión, Fermi logra un rendimiento
casi óptimo del hardware.

La mayoría de las instrucciones pueden ser de doble emisión; se pueden emitir

simultáneamente dos instrucciones enteras, dos instrucciones flotantes o una combinación de
instrucciones enteras, de punto flotante, carga, almacenamiento y SFU. Las instrucciones de
doble precisión no admiten el envío doble con ninguna otra operación.

64 KB de memoria compartida configurable y caché L1

Una de las innovaciones arquitectónicas clave que mejoró enormemente tanto la capacidad de
programación como el rendimiento de las aplicaciones GPU es la memoria compartida en el
chip. La memoria compartida permite que los subprocesos dentro del mismo bloque de
subprocesos cooperen, facilita la reutilización extensa de datos en chip y reduce en gran medida
el tráfico fuera de chip. La memoria compartida es un habilitador clave para muchas aplicaciones
CUDA de alto rendimiento.
G80 y GT200 tienen 16 KB de memoria compartida por SM. En la arquitectura Fermi, cada SM tiene
64 KB de memoria en chip que se pueden configurar como 48 KB de memoria compartida con 16 KB
de caché L1 o como 16 KB de memoria compartida con 48 KB de caché L1.

10
Para las aplicaciones existentes que hacen un uso extensivo de la memoria compartida, triplicar la
cantidad de memoria compartida produce mejoras significativas en el rendimiento, especialmente
para problemas que están restringidos por ancho de banda. Para las aplicaciones existentes que
usan la memoria compartida como caché administrada por software, el código puede ser optimizado
para aprovechar el sistema de almacenamiento en caché del hardware, mientras sigue teniendo
acceso a al menos 16 KB de memoria compartida para la cooperación explícita de subprocesos.
Lo mejor de todo es que las aplicaciones que no usan la memoria compartida se benefician
automáticamente de la memoria caché L1, lo que permite que los programas CUDA de alto
rendimiento se creen con el mínimo tiempo y esfuerzo.

Tabla de resumen
GPU G80 GT200 Fermi
Transistores 681 million 1.4 billion 3.0 billion
CUDA Cores 128 240 512
Doble precisión flotante None 30 FMA ops / clock 256 FMA ops /clock
Capacidad de puntos
Flotante de precisión simple 128 MAD 240 MAD ops / 512 FMA ops /clock
Capacidad de puntos ops/clock clock
Programadores Warp (por 1 1 2
SM)
Unidades de funciones 2 2 4
especiales (SFU) / SM
Memoria compartida (por SM) 16 KB 16 KB Configurable 48 KB or
16 KB
Caché L1 (por SM) None None Configurable 16 KB or
48 KB
Caché L2 (por SM) None None 768 KB
Soporte de memoria ECC No No Yes
Kernels concurrentes No No Up to 16
Ancho de dirección de carga / 32-bit 32-bit 64-bit
almacenamiento

Ejecución de subprocesos paralelos de segunda generación ISA

Fermi es la primera arquitectura que admite el nuevo conjunto de instrucciones Parallel Thread
eXecution (PTX) 2.0. PTX es una máquina virtual de bajo nivel e ISA diseñada para admitir las
operaciones de un procesador de subproceso paralelo. En el momento de la instalación del
programa, las instrucciones PTX se convierten en instrucciones de la máquina mediante el
controlador de GPU. Los objetivos principales de PTX son:

❑ Proporcionar una ISA estable que abarque varias generaciones de GPU

❑ Lograr el rendimiento completo de GPU en aplicaciones compiladas
❑ Proporcione una ISA independiente de la máquina para C, C ++, Fortran y otros objetivos del
compilador.
❑ Proporcionar una distribución de código ISA para desarrolladores de aplicaciones y middleware.
❑ Proporcionar un ISA común para optimizar generadores de código y traductores, que mapean
PTX para especificar máquinas de destino.
❑ Facilita la codificación manual de bibliotecas y núcleos de rendimiento.
❑ Proporcione un modelo de programación escalable que abarca tamaños de GPU desde
unos pocos núcleos hasta muchos núcleos paralelos
11
PTX 2.0 presenta varias características nuevas que mejoran en gran medida la capacidad de
programación, precisión y rendimiento de la GPU. Estos incluyen: precisión IEEE completa de punto
flotante de 32 bits, espacio de direcciones unificado para todas las variables y punteros,
direccionamiento de 64 bits y nuevas instrucciones para OpenCL y DirectCompute. Lo más
importante es que PTX 2.0 fue diseñado específicamente para proporcionar soporte completo para
el lenguaje de programación C ++.

El espacio de direcciones unificadas habilita el soporte completo de C ++

Fermi y PTX 2.0 ISA implementan un espacio de direcciones unificado que unifica los tres
espacios de direcciones separados (subprocesos local, bloque compartido y global) para las
operaciones de carga y almacenamiento. En PTX 1.0, las instrucciones de carga /
almacenamiento eran específicas de uno de los tres espacios de direcciones; los programas
podrían cargar o almacenar valores en un espacio de direcciones de destino específico
conocido en el momento de la compilación. Fue difícil implementar totalmente los punteros C
y C ++, ya que el espacio de direcciones de destino del puntero puede no conocerse en el
momento de la compilación, y solo puede determinarse dinámicamente en el tiempo de
ejecución.
Con PTX 2.0, un espacio de direcciones unificado unifica los tres espacios de direcciones en un
espacio de direcciones único y continuo. Un solo conjunto de instrucciones de carga /
almacenamiento unificadas operan en este espacio de direcciones, aumentando los tres conjuntos
de instrucciones de carga / almacenamiento para la memoria local, compartida y global. El espacio
de direcciones unificadas de 40 bits admite un Terabyte de memoria direccionable, y el ISA de carga
/ almacenamiento admite el direccionamiento de 64 bits para el crecimiento futuro.

La implementación de un espacio de direcciones unificado permite a Fermi admitir verdaderos

programas de C ++. En C ++, todas las variables y funciones residen en objetos que se pasan a
12
través de punteros. PTX 2.0 hace posible utilizar punteros unificados para pasar objetos en cualquier
espacio de memoria, y la unidad de traducción de direcciones de hardware de Fermi asigna
automáticamente las referencias de los punteros al espacio de memoria correcto.
Fermi y el PTX 2.0 ISA también agregan soporte para las funciones virtuales de C ++, los punteros
de función y los operadores "nuevo" y "eliminar" para la asignación y desasignación dinámica de
objetos. También se admiten las operaciones de manejo de excepciones de C ++ "try" y "catch".

Optimizado para OpenCL y DirectCompute

OpenCL y DirectCompute están estrechamente relacionados con el modelo de programación

CUDA, compartiendo las abstracciones clave de hilos, bloques de hilos, cuadrículas de
bloques de hilos, sincronización de barrera, memoria compartida por bloque, memoria global y
operaciones atómicas. Fermi, una arquitectura CUDA de tercera generación, está, por
naturaleza, bien optimizada para estas API. Además, Fermi ofrece soporte de hardware para
las instrucciones de superficie de OpenCL y DirectCompute con conversión de formatos, lo
que permite que los gráficos y los programas informáticos funcionen fácilmente con los
mismos datos. El PTX 2.0 ISA también agrega soporte para el conteo, la adición y el retroceso
de bits de DirectCompute.

Precisión de punto flotante IEEE de 32 bits

Las instrucciones de punto flotante de precisión simple ahora admiten números subnormales por
defecto en el hardware, así como los cuatro modos de redondeo IEEE 754-2008 (el más cercano,
cero, infinito positivo e infinito negativo).
Los números subnormales son números pequeños que se encuentran entre cero y el número
normalizado más pequeño de un sistema numérico de punto flotante dado. Las GPU de
generaciones anteriores redirigieron los operandos subnormales y los resultados a cero, incurriendo
en una pérdida de precisión. Las CPU normalmente realizan cálculos subnormales en el software de
manejo de excepciones, y toman miles de ciclos. Las unidades de punto flotante de Fermi manejan
números subnormales en hardware, lo que permite que los valores suban gradualmente a cero sin
penalización de rendimiento.

Una secuencia de operaciones que se usa con frecuencia en gráficos de computadora, álgebra
lineal y aplicaciones científicas es multiplicar dos números, agregando el producto a un tercer
número, por ejemplo, D = A × B + C. Las GPU de la generación anterior aceleraron esta función con
la multiplicación-add (MAD) instrucción que permitió que ambas operaciones se realizaran en un
solo reloj. La instrucción MAD realiza una multiplicación con truncamiento, seguida de una suma con
redondear al par más cercano. Fermi implementa la nueva instrucción fusionada de adición múltiple
(FMA) para los números de punto flotante de precisión doble de 32 bits y de precisión doble de 64
bits (GTMA compatible con FMA solo en precisión doble) que mejora la adición múltiple al mantener
una precisión total La etapa intermedia. El aumento de la precisión beneficia a una serie de
algoritmos, como la representación de geometría de intersección fina, una mayor precisión en los
cálculos matemáticos iterativos y operaciones de división rápida y de raíz cuadrada, redondeadas
con precisión.

13
 Mejora del rendimiento condicional a través de la predicción
En el ISA de Fermi, el soporte de predicción de hardware nativo utilizado para la administración de
subprocesos divergentes ahora está disponible en el nivel de instrucción. La predicción permite que
los segmentos de código condicionales cortos se ejecuten de manera eficiente sin una sobrecarga
de instrucciones de bifurcación.

14
Innovaciones del subsistema de memoria

NVIDIA Parallel DataCacheTM con L1 configurable y Unified L2 Cache

Al trabajar con cientos de aplicaciones

informáticas de GPU de diversas industrias,
aprendimos que si bien la memoria compartida
beneficia muchos problemas, no es apropiada
para todos los problemas. Algunos algoritmos
se asignan de forma natural a la memoria
compartida, otros requieren un caché, mientras
que otros requieren una combinación de ambos.
La jerarquía de memoria óptima debería ofrecer
los beneficios tanto de la memoria compartida
como de la memoria caché, y permitir al
programador una opción sobre su partición. La
jerarquía de memoria de Fermi se adapta a
ambos tipos de comportamiento del programa.

Agregar una jerarquía de caché verdadera para

las operaciones de carga / almacenamiento
presentó desafíos significativos. Las
arquitecturas de GPU tradicionales admiten una
ruta de "carga" de solo lectura para operaciones
de textura y una ruta de "exportación" de solo
escritura para la salida de datos de píxeles. Sin
embargo, este enfoque es poco adecuado para
ejecutar programas de subprocesos C o C ++
de propósito general que esperan que las multiprocesador SM y un caché L2 unificado que
lecturas y escrituras se ordenen. Como un atiende todas las operaciones (carga,
ejemplo: derramar un operando de registro en la almacenamiento y textura). El caché per-SM L1
se puede configurar para admitir tanto la memoria
memoria y luego leerlo de nuevo crea un peligro compartida como el almacenamiento en caché de
de lectura después de la escritura; si las rutas las operaciones de memoria local y global. La
de lectura y escritura son independientes, memoria de 64 KB se puede configurar como 48
puede ser necesario vaciar explícitamente la KB de memoria compartida con 16 KB de caché
ruta de escritura / "exportación" completa antes L1 o 16 KB de memoria compartida con 48 KB de
de que sea seguro emitir la lectura, y cualquier caché L1. Cuando se configuran con 48 KB de
memoria compartida, los programas que hacen
caché en la ruta de lectura no sería coherente un uso extensivo de la memoria compartida
con respecto a escribir datos. (como las simulaciones electrodinámicas) pueden
La arquitectura Fermi aborda este desafío ejecutarse hasta tres veces más rápido. Para los
mediante la implementación de una única ruta programas cuyos accesos a la memoria no se
de solicitud de memoria unificada para cargas y conocen de antemano, la configuración del caché
almacenes, con un caché L1 por de 48 KB L1 ofrece un rendimiento mejorado en
comparación con el acceso directo a la DRAM.

15
 In either configuration, the
Radix Sort using Shared Memory L1 cache also helps by
caching temporary register
500%
spills of complex programs.
450%
Prior generation GPUs
400%
spilled registers directly to
350% DRAM, increasing access
300% latency. With the L1 cache,
250% performance scales
200% gracefully with increased
150% temporary register usage.
100%
50%
0% Fermi features a 768 KB
GT200 Architecture Fermi Architecture unified L2 cache that
When using 48 KB of shared memory on Fermi, Radix Sort executes
services all load, store, and
4.7x faster than GT200. texture requests. The L2
provides efficient, high
speed data sharing across
the GPU. Algorithms for
which data addresses are
PhysX Fluid Collision for Convex Shapes
not known beforehand, such
300% as physics solvers,
raytracing, and sparse
250% matrix multiplication
especially benefit from the
200%
cache hierarchy. Filter and
convolution kernels that
150%
require multiple SMs to read
100% the same data also benefit.

50%

0%
GT200 Architecture Fermi Architecture
Physics algorithms such as fluid simulations especially benefit from Fermi’s
caches. For convex shape collisions, Fermi is 2.7x faster than GT200.

16
First GPU with ECC Memory Support

Fermi is the first GPU to support Error Correcting Code (ECC) based protection of data in
memory. ECC was requested by GPU computing users to enhance data integrity in high
performance computing environments. ECC is a highly desired feature in areas such as
medical imaging and large-scale cluster computing.

Naturally occurring radiation can cause a bit stored in memory to be altered, resulting in a soft
error. ECC technology detects and corrects single-bit soft errors before they affect the system.
Because the probability of such radiation induced errors increase linearly with the number of
installed systems, ECC is an essential requirement in large cluster installations.

Fermi supports Single-Error Correct Double-Error Detect (SECDED) ECC codes that correct
any single bit error in hardware as the data is accessed. In addition, SECDED ECC ensures
that all double bit errors and many multi-bit errors are also be detected and reported so that
the program can be re-run rather than being allowed to continue executing with bad data.

Fermi’s register files, shared memories, L1 caches, L2 cache, and DRAM memory are ECC
protected, making it not only the most powerful GPU for HPC applications, but also the most
reliable. In addition, Fermi supports industry standards for checking of data during
transmission from chip to chip. All NVIDIA GPUs include support for the PCI Express standard
for CRC check with retry at the data link layer. Fermi also supports the similar GDDR5 standard
for CRC check with retry (aka “EDC”) during transmission of data across the memory bus.

Fast Atomic Memory Operations

Atomic memory operations are important in parallel programming, allowing concurrent threads
to correctly perform read-modify-write operations on shared data structures. Atomic
operations such as add, min, max, and compare-and-swap are atomic in the sense that the
read, modify, and write operations are performed without interruption by other threads. Atomic
memory operations are widely used for parallel sorting, reduction operations, and building data
structures in parallel without locks that serialize thread execution.

Thanks to a combination of more atomic units in hardware and the addition of the L2 cache,
atomic operations performance is up to 20× faster in Fermi compared to the GT200 generation.

17
GigaThreadTM Thread Scheduler
One of the most important technologies of the Fermi architecture is its two-level, distributed
thread scheduler. At the chip level, a global work distribution engine schedules thread blocks
to various SMs, while at the SM level, each warp scheduler distributes warps of 32 threads to
its execution units. The first generation GigaThread engine introduced in G80 managed up to
12,288 threads in realtime. The Fermi architecture improves on this foundation by providing not
only greater thread throughput, but dramatically faster context switching, concurrent kernel
execution, and improved thread block scheduling.

10x Faster Application Context Switching

Like CPUs, GPUs support multitasking through the use of context switching, where each
program receives a time slice of the processor’s resources. The Fermi pipeline is optimized to
reduce the cost of an application context switch to below 25 microseconds, a significant
improvement over last generation GPUs. Besides improved performance, this allows
developers to create applications that take greater advantage of frequent kernel-to-kernel
communication, such as fine-grained interoperation between graphics and PhysX applications.

Concurrent Kernel Execution

Fermi supports concurrent kernel execution, where different kernels of the same application
context can execute on the GPU at the same time. Concurrent kernel execution allows
programs that execute a number of small kernels to utilize the whole GPU. For example, a
PhysX program may invoke a fluids solver and a rigid body solver which, if executed
sequentially, would use only half of the available thread processors. On the Fermi architecture,
different kernels of the same CUDA context can execute concurrently, allowing maximum
utilization of GPU resources. Kernels from different application contexts can still run
sequentially with great efficiency thanks to the improved context switching performance.

Kernel1 Kernel2

Kernel3 Kernel4

Kernel5

Serial Kernel Execution Concurrent Kernel Execution

18
Introducing NVIDIA Nexus
NVIDIA Nexus is the first development environment designed specifically to support massively
parallel CUDA C, OpenCL, and DirectCompute applications. It bridges the productivity gap
between CPU and GPU code by bringing parallel-aware hardware source code debugging and
performance analysis directly into Microsoft Visual Studio, the most widely used integrated
application development environment under Microsoft Windows.

Nexus allows Visual Studio developers to write and debug GPU source code using exactly the
same tools and interfaces that are used when writing and debugging CPU code, including
source and data breakpoints, and memory inspection. Furthermore, Nexus extends Visual
Studio functionality by offering tools to manage massive parallelism, such as the ability to
focus and debug on a single thread out of the thousands of threads running parallel, and the
ability to simply and efficiently visualize the results computed by all parallel threads.

Nexus is the perfect environment to develop co-processing applications that take advantage of
both the CPU and GPU. It captures performance events and information across both
processors, and presents the information to the developer on a single correlated timeline. This
allows developers to see how their application behaves and performs on the entire system,
rather than through a narrow view that is focused on a particular subsystem or processor.

NVIDIA Nexus integrated development environment

19
Conclusion
For sixteen years, NVIDIA has dedicated itself to building the world’s fastest graphics
processors. While G80 was a pioneering architecture in GPU computing, and GT200 a major
refinement, their designs were nevertheless deeply rooted in the world of graphics. The Fermi
architecture represents a new direction for NVIDIA. Far from being merely the successor to
GT200, Fermi is the outcome of a radical rethinking of the role, purpose, and capability of the
GPU.

Rather than taking the simple route of adding execution units, the Fermi team has tackled
some of the toughest problems of GPU computing. The importance of data locality is
recognized through Fermi’s two level cache hierarchy and its combined load/store memory
path. Double precision performance is elevated to supercomputing levels, while atomic
operations execute up to twenty times faster. Lastly, Fermi’s comprehensive ECC support
strongly demonstrates our commitment to the high-performance computing market.

On the software side, the architecture brings forward support for C++, the world’s most
ubiquitous object-orientated programming language, and Nexus, the world’s first integrated
development environment designed for massively parallel GPU computing applications.

With its combination of ground breaking performance, functionality, and programmability, the
Fermi architecture represents the next revolution in GPU computing.

20
Notice
ALL INFORMATION PROVIDED IN THIS WHITE PAPER, INCLUDING COMMENTARY, OPINION, NVIDIA DESIGN
SPECIFICATIONS, REFERENCE BOARDS, FILES, DRAWINGS, DIAGNOSTICS, LISTS, AND OTHER DOCUMENTS (TOGETHER
AND SEPARATELY, “MATERIALS”) ARE BEING PROVIDED “AS IS.” NVIDIA MAKES NO WARRANTIES, EXPRESSED, IMPLIED,
STATUTORY, OR OTHERWISE WITH RESPECT TO MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF
NONINFRINGEMENT, MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.

Information furnished is believed to be accurate and reliable. However, NVIDIA Corporation assumes no responsibility for the
consequences of use of such information or for any infringement of patents or other rights of third parties that may result from its
use. No license is granted by implication or otherwise under any patent or patent rights of NVIDIA Corporation. Specifications
mentioned in this publication are subject to change without notice. This publication supersedes and replaces all information
previously supplied. NVIDIA Corporation products are not authorized for use as critical components in life support devices or
systems without express written approval of NVIDIA Corporation.

Trademarks
NVIDIA, the NVIDIA logo, CUDA, FERMI and GeForce are trademarks or registered trademarks of NVIDIA Corporation in the United
States and other countries. Other company and product names may be trademarks of the respective companies with which they
are associated.

Copyright
© 2009 NVIDIA Corporation. All rights reserved.