Download 740 KB PPT - GPGPU.org

Survey
yes no Was this document useful for you?
   Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Document related concepts

Indexed color wikipedia, lookup

Intel GMA wikipedia, lookup

2.5D wikipedia, lookup

Spatial anti-aliasing wikipedia, lookup

Tektronix 4010 wikipedia, lookup

Molecular graphics wikipedia, lookup

Mesa (computer graphics) wikipedia, lookup

Hold-And-Modify wikipedia, lookup

GeForce 7 series wikipedia, lookup

InfiniteReality wikipedia, lookup

GeForce 8 series wikipedia, lookup

Waveform graphics wikipedia, lookup

BSAVE (bitmap format) wikipedia, lookup

Original Chip Set wikipedia, lookup

Apple II graphics wikipedia, lookup

Free and open-source graphics device driver wikipedia, lookup

Video card wikipedia, lookup

Stream processing wikipedia, lookup

Framebuffer wikipedia, lookup

Graphics processing unit wikipedia, lookup

General-purpose computing on graphics processing units wikipedia, lookup

Transcript
General-Purpose Computation on
Graphics Hardware
Introduction
David Luebke
University of Virginia
Course Introduction
• The GPU on commodity video cards has
evolved into an extremely flexible and
powerful processor
– Programmability
– Precision
– Power
• This course will address how to harness that
power for general-purpose computation
Motivation: Computational Power
• GPUs are fast…
–
–
–
–
3.0 GHz dual-core Pentium4: 24.6 GFLOPS
NVIDIA GeForceFX 7800: 165 GFLOPs
1066 MHz FSB Pentium Extreme Edition : 8.5 GB/s
ATI Radeon X850 XT Platinum Edition: 37.8 GB/s
• GPUs are getting faster, faster
– CPUs: 1.4× annual growth
– GPUs: 1.7×(pixels) to 2.3× (vertices) annual growth
Courtesy Kurt Akeley,
Ian Buck & Tim Purcell, GPU Gems (see course notes)
Motivation: Computational Power
Courtesy Ian Buck, John Owens
An Aside: Computational Power
• Why are GPUs getting faster so fast?
– Arithmetic intensity: the specialized nature of GPUs
makes it easier to use additional transistors for
computation not cache
– Economics: multi-billion dollar video game market is
a pressure cooker that drives innovation
Motivation: Flexible and Precise
• Modern GPUs are deeply programmable
– Programmable pixel, vertex, video engines
– Solidifying high-level language support
• Modern GPUs support high precision
– 32 bit floating point throughout the pipeline
– High enough for many (not all) applications
Motivation: The Potential of GPGPU
• In short:
– The power and flexibility of GPUs makes them an
attractive platform for general-purpose computation
– Example applications range from in-game physics
simulation to conventional computational science
– Goal: make the inexpensive power of the GPU
available to developers as a sort of computational
coprocessor
The Problem: Difficult To Use
• GPUs designed for & driven by video games
– Programming model unusual
– Programming idioms tied to computer graphics
– Programming environment tightly constrained
• Underlying architectures are:
– Inherently parallel
– Rapidly evolving (even in basic feature set!)
– Largely secret
• Can’t simply “port” CPU code!
Course goals
• A detailed introduction to general-purpose
computing on graphics hardware
• We emphasize:
– Core computational building blocks
– Strategies and tools for programming GPUs
– Tips & tricks, perils & pitfalls of GPU programming
• Case studies to bring it all together
Why a SIGGRAPH Course?
• Why SIGGRAPH, not (say) Supercomputing?
– Many graphics applications can benefit from GPGPU
• “Hot topic” examples: shadows, level sets, fluids
• Keeping computation on-card!
– Many graphics applications strive for visual
plausibility rather than rigorous scientific realism
• Better tolerate GPU limitations in precision, memory
• Well suited as GPGPU “early adopters”
– GPGPU programming still requires expertise of
SIGGRAPH audience
Course Prerequisites
• We assume
– Familiarity with interactive graphics and computer
graphics hardware
– Ideally, some experience programming vertex and
pixel shaders
• Target audience
– Researchers interested in GPGPU
– Graphics and games developers interested in
incorporating these techniques into their work
– Attendees wishing a survey of this exciting field
Course Topics
•
•
•
•
GPU building blocks
Languages and tools
Effective GPU programming
GPGPU case studies
Course Topics: Details
• GPU building blocks
– Linear algebra
– Sorting and searching
– Geometric Computing
• Languages and tools
– High-level languages
– Debugging tools
Course Topics: Details
• Effective GPU programming
–
–
–
–
Efficient data-parallel programming
GPU memory resources & data layout approaches
GPU computation strategies & tricks
Data structures
• Case studies in GPGPU Programming
– Databases and data mining operations on GPUs
– Particles & grids on GPUs
– Adaptive shadow maps & octree textures on GPUs
Speakers
• In order of appearance:
–
–
–
–
–
–
–
–
David Luebke, University of Virginia
Mark Harris, NVIDIA
Jens Krüger, TU-Munich
Tim Purcell, NVIDIA
Naga Govindaraju, University of North Carolina
Ian Buck, NVIDIA
Cliff Woolley, University of Virginia
Aaron Lefohn, University of California Davis
Schedule
8:30
Introduction
Luebke
Welcome, overview, the graphics pipeline
GPU Building Blocks
8:50 Computational concepts: CPUGPU
Harris
Streaming, resources, CPU-GPU analogies, branching
9:15
Linear algebra
Krüger
Representations, operations, example algorithms
9:50
Sorting & Searching
Bitonic sort, Binary & k-nearest neighbor search
10:15 Break
Purcell
Schedule
10:30 Geometric computation
Govindaraju
Visibility, collision & proximity, reliable computation
Languages and Tools
11:00 High-level languages
Buck
Cg/HLSL/GLslang, Sh, Brook
11:30 Debugging tools
imdebug, DirectX/OpenGL shader IDEs, ShadeSmith
Purcell
Schedule
Effective GPGPU Programming
11:50 GPU program optimization
Woolley
Computational frequency, profiling, load balancing
12:15 Lunch break
1:45 GPU memory models
Lefohn
Memory objects, layout of data structures, FBOs
2:15
GPU computation strategies & tricks
Buck
Precision, performance, scatter, branching
2:55
GPU data structures
High-level data structures
3:30
Break
Lefohn
Schedule
Case Studies
3:45 Databases & data mining on GPUs
Govindaraju
Queries, aggregation, mining frequencies & quantiles
4:15
Geometry processing on GPUs
Krüger
Particles, grids, PBO/VBO vs. FBO vs. VTF/SM3.0
4:45
Applications of adaptive
data structures
Lefohn
Adaptive shadow maps, octree textures
Conclusion
5:15 Question-and-answer session
5:30 Wrap!
All
GPU Fundamentals: The Graphics Pipeline
Graphics State
GPU
Shade
Final Pixels (Color, Depth)
Rasterize
Fragments (pre-pixels)
Assemble
Primitives
Screenspace triangles (2D)
Transform
& Light
Xformed, Lit Vertices (2D)
CPU
Vertices (3D)
Application
Video
Memory
(Textures)
Render-to-texture
• A simplified graphics pipeline
– Note that pipe widths vary
– Many caches, FIFOs, and so on not shown
GPU Fundamentals: The Modern Graphics Pipeline
Graphics State
• Programmable vertex
processor!
GPU
Fragment
Shade
Processor
Final Pixels (Color, Depth)
CPU
Rasterize
Fragments (pre-pixels)
Assemble
Primitives
Screenspace triangles (2D)
Xformed, Lit Vertices (2D)
Vertices (3D)
Application
Vertex
Transform
Processor
Video
Memory
(Textures)
Render-to-texture
• Programmable pixel
processor!
The Coming Soon Graphics Pipeline
Graphics State
• Programmable
primitive assembly!
GPU
Fragment
Processor
Final Pixels (Color, Depth)
CPU
Rasterize
Fragments (pre-pixels)
Geometry
Assemble
Processor
Primitives
Screenspace triangles (2D)
Xformed, Lit Vertices (2D)
Vertices (3D)
Application
Vertex
Processor
Video
Memory
(Textures)
Render-to-texture
• More flexible memory
access!
GPU Pipeline: Transform
• Vertex processor (multiple in parallel)
– Transform from “world space” to “image space”
– Compute per-vertex lighting
GPU Pipeline: Rasterize
• Rasterizer
– Convert geometric rep. (vertex) to image rep.
(fragment)
• Fragment = image fragment
– Pixel + associated data: color, depth, stencil, etc.
– Interpolate per-vertex quantities across pixels
GPU Pipeline: Shade
• Fragment processors (multiple in parallel)
– Compute a color for each pixel
– Optionally read colors from textures (images)
Coming Up
• Next: Mapping computational concepts
to the GPU
• Also coming up:
– Core building blocks for GPGPU computing
– Memory layout, data structures, and algorithms
– Detailed advice on writing high performance
GPGPU code
– Lots of examples
Course Evaluation Form
• Please help us improve the GPGPU Course
• Fill out the SIGGRAPH evaluation form:
http://www.siggraph.org/cgi-bin/cgi/exCoursesEval.html
Choose Course 39: GPGPU