GPU ARCHITECTURE TDT24 MIGUEL ÁNGEL MARTÍNEZ DEL AMOR

Transkript

1 GPU ARCHITECTURE TDT24 MIGUEL ÁNGEL MARTÍNEZ DEL AMOR

2 OUTLINE GRAPHICS HISTORY SHORT REVIEW (3). GPU ARCHITECTURE. EVOLUTION (11). GPU SHADER PROGRAMMING (7). FUTURE WORK (2). REFERENCES (1). Scientific Computing 2

3 GRAPHICS HISTORY SHORT REVIEW (I) WHIRLWIND PROJECT: Jay Forrester (core memory) and Ken Olsen of MIT. Programmable flight simulator computer for the Navy (ASCA). It was the first interactive computer. SAGE PROJECT: Based on Whirldwind project for general purpose. They used the light pen. TX-0 AND TX-2 Transistorized Whirlwind. Scientific Computing 3

4 GRAPHICS HISTORY SHORT REVIEW (II) SUTHERLAND S SKETCHPAD: He is the grandfather of interactive computer graphics (direct manipulation computer graphic interface of today). Sketchpad is the antecessor of CAD and GUI. It was a program written for the TX-2 that allowed a user to draw and manage pints, line and arcs on a CRT monitor using a light pen. 1967, IDIIOM became the first CAD workstation. Scientific Computing 4

5 GRAPHICS HISTORY SHORT REVIEW (III) PC REVOLUTION: With commercial graphics software like videogames, graphic cards became an essential and critical component of computers. 1981: First video card (by IBM). 1983: First GUI: VisiOn. 1984: PGA into the Intel microprocessor. Scientific Computing 5

6 GPU ARCHITECTURE. EVOLUTION (I) GPU have became more powerful with 3D applications. More complex than general-purpose CPU: based on streaming. Use of SIMD structure. Graphics pipeline is a model of stages where the graphics data go through. Part of the pipeline is implemented on SW (CPU) and the other part on HW (GPU). Scientific Computing 6

7 GPU ARCHITECTURE. EVOLUTION (II) The inputs of the pipeline are the form of models or 3D coordinates (easy for the programmer) and the outputs are pixels (displayed on a 2D screen). General stages: Scientific Computing 7

8 GPU ARCHITECTURE. EVOLUTION (III) GEOMETRY STAGE: Changes 3D coordinates into 2D windows coordinates. T&L: Transformation is displaying a 3D object into 2D windows coordinate. Lighting provides lighting effects to the scene. TS: Clip and set up the triangles (make fragments). RENDERING STAGE: Fill the area between 2D coordinates with pixels to represent the surface of the object. Scientific Computing 8

9 GPU ARCHITECTURE. EVOLUTION (IV) When the triangle setup (and before stages) was implemented in software, the CPU had to compute all the triangle calculations, so the CPU became a bottleneck. Then, the triangle setup stage was implemented on hardware (GPU), and the CPU were able to output more triangles than the GPU could handle: GPU became a bottleneck. Scientific Computing 9

10 GPU ARCHITECTURE. EVOLUTION (V) The problem came from the rendering stage: the process for drawing a single pixel took many clock cycles. Solution: Pipelining and parallelism. Good because the inherent parallelism between graphics data (independent vertices). Scientific Computing 10

11 GPU ARCHITECTURE. EVOLUTION (VI) The CPU became again a bottleneck (GPU could handle more triangles than the CPU could output). Solution: Implement T&L (and then all the 3D stages) on hardware, because they are very math intensive processes. Scientific Computing 11

12 GPU ARCHITECTURE. EVOLUTION (VII) Evolution of the implementation of the stages (by Nvidia): Scientific Computing 12

13 GPU ARCHITECTURE. EVOLUTION (VIII) The pipeline was called fixed function pipeline. A generic final block diagram is: Scientific Computing 13

14 GPU ARCHITECTURE. EVOLUTION (IX) Although it was faster, the implementation of all pipeline on HW had a constant behavior: it always make the same calculations with the 3D data. So it is not flexible, i.e., in case of change the API (the HW will not take the advantage of the new API). Solution: Programmable pipeline (the GPU can execute instructions). Scientific Computing 14

15 GPU ARCHITECTURE. EVOLUTION (X) In programmable pipeline, it is sent to the GPU the data and some instructions. Use of Shader programs. Shader: pieces of code that program certain parts of the pipeline. There are 2 types: Vertex shaders (change T&L) and Fragment (or pixel) shaders (change texturing and color sum & fog). Scientific Computing 15

16 GPU ARCHITECTURE. EVOLUTION (XI) Final structure overview: Scientific Computing 16

17 GPU SHADER PROGRAMMING (I) VERTEX SHADER: Program that has only one vertex as input and one vertex as output. FRAGMENT SHADER: A fragment is a pint in windows coordinates produced by rasterizer stage that has attributes as color, depth One pixel (a dot of color) corresponds to multiple fragments. Program that has vertex shader outputs interpolated across a primitive as input and a simple colour and a depth value as output. Scientific Computing 17

18 GPU SHADER PROGRAMMING (II) Shading languages are low-level (like assembler), but nowadays there are high-level languages. The data type in shading languages is a 4-component vector for floating-point values. Use of SIMD instructions working on the 4 components at the same time. Fragment shaders are usually less powerful than vertex shaders, but in the future it will be the same (same instruction set and syntax). General instruction syntax: Opcode DestReg, SrcReg1 [,SrcReg2] [,SrcReg3] Scientific Computing 18

19 GPU SHADER PROGRAMMING (III) LOW-LEVEL SHADING LANGUAGES: Direct3D 8 Shading Languages: There are not instructions for sine and cosine functions (use of Taylor series). Direct3D does not differentiate between fragment and pixel. Pixel Shader is very primitive. Of course, it only works on Microsoft systems. NV_Vertex_Program: It is an OpenGL extension that defines a vertex shader execution environment (made by Nvidia). Basically the same computational powerful than DirectX 8 Vertex Shader. Scientific Computing 19

20 GPU SHADER PROGRAMMING (IV) ARB_Vertex_Program: It is a vertex shading language for OpenGL. The instruction set and syntax are the same than NV_Vertex_Program. It does not have fixed register names (by declaration before the use). It can handle states variables for the OpenGL state machine. Direct3D 9 Shading Languages: Versions 2.x and 3.0 (support of loops, subroutines call ). New counters data type for loops. Improving of pixel shader (more powerful than before). Scientific Computing 20

21 GPU SHADER PROGRAMMING (V) NV_Vertex_Program2: For Nvidia s newest generation of GPU GeForce FX. ARB_Fragment_Program: It is as powerful as ARB_Vertex_Program. It supports sine, cosine and exponentiation instructions. It does not support loops and subroutines calls (so, less powerful than Direct3D 9 version 3.0). NV_Fragment_Program: It corresponds to the Direct3D 9 fragment shading language version 2.x. Scientific Computing 21

22 GPU SHADER PROGRAMMING (VI) HIGH-LEVEL SHADING LANGUAGES: Commonly based on C syntax with limited data types. Standford Real-time Shading Language: It does not distinguish between vertex and fragment shaders (only one called surface shader), but the compiler internally make two shader codes for vertex and fragment shaders. Scientific Computing 22

23 GPU SHADER PROGRAMMING (VII) Cg/Direct3D HLSL: C for graphics, made by Nvidia. It has separate codes for vertex and fragment shaders. When compiling, it must be specified a profile (target language) because, i.e., ARB_Vertex_Program does not support if-statements. The Cg language is similar to C, and support data types as scalar, vector and matrix types. Also it is possible to use pre-defined fuctions as sine and cosine. HLSL is syntactically and semantically equivalent to Cg. GLSlang: GL Shading Language, that will be introduced with OpenGL 2.0. It is similar to Cg. Scientific Computing 23

24 FUTURE WORK (I) Unified Shader units: Vertex and fragment shading languages are very similar, so it is possible to unify them. I.e.: If it is needed more vertex shader units than fragment shader units in a given moment, it is possible to share resources because of the use of unified shader units. The rendered frames become limited by the memory system rather tan by fragment shading. It will be supported by future languages as shader Model 4.0 in Direct3D and OpenGL GLSlang. Scientific Computing 24

25 FUTURE WORK (II) GPU for General Purpose Computation: Shading languages becomes powerful and complex from the last years, and then, a new research field appears that studies the General Purpose Computation on Graphics Processing Units (GPGPU ( But it is not trivial, the general purpose application and data nature is different than graphics application and data (streaming) nature. There is some compilers in research, i.e., BrookGPU (extension of ANSI C to support the execution of general purpose applications). Sometimes GPGPU does not have performance than CPU yet. Scientific Computing 25

26 REFERENCES Thomas Scott Crow. Evolution of the Graphical Processing Unit. December Martin Ecker. XEngine Programmable Graphics Pipeline Architectures. March Architectures.pdf Victor Moya, Carlos Gonzalez, Jordi Roca, Agustin Fernandez, Roger Espasa. Shader Performance Analysis on a Modern GPU Architecture. November Victor Moya, Carlos Gonzalez, Jordi Roca, Agustin Fernandez, Roger Espasa. An End to End, Highly Detailed Simulator for the ATILA GPU Microarchitecture. Pushkar Joshi, Leslie Ikemoto. Harnessing the GPU for General Purpose Computation: A Case Study. December Pedro Trancoso, Maria Charalambous. Exploring Graphics Processor Performance for General Purpose Applications. Scientific Computing 26