Status – Week 254 Victor Moya. Summary Command Processor. Command Processor. Memory Controller. Memory Controller. Streamer. Streamer. Vertex buffers.

Slides:



Advertisements
Similar presentations
Vertex Buffer Objects, Vertex Array Objects, Pixel Buffer Objects.
Advertisements

EECS 700: Computer Modeling, Simulation, and Visualization Dr. Shontz Chapter 2: Shader Fundamentals (continued)
11/8/2005Comp 120 Fall November 9 classes to go! Read Section 7.5 especially important!
Week 8 Arrays Part 2 String & Pointer
Understanding the graphics pipeline Lecture 2 Original Slides by: Suresh Venkatasubramanian Updates by Joseph Kider.
Status – Week 257 Victor Moya. Summary GPU interface. GPU interface. GPU state. GPU state. API/Driver State. API/Driver State. Driver/CPU Proxy. Driver/CPU.
Status – Week 250 Victor Moya. Summary Current State. Current State. Next Tasks. Next Tasks. Future Work. Future Work. Creditos investigación. Creditos.
Status – Week 249 Victor Moya. Summary MemoryController. MemoryController. Streamer. Streamer. TraceDriver. TraceDriver. Statistics. Statistics.
Computer Graphics Ben-Gurion University of the Negev Fall 2012.
Status – Week 259 Victor Moya. Summary OpenGL Traces. OpenGL Traces. DirectX Traces. DirectX Traces. Proxy CPU. Proxy CPU. Command Processor. Command.
© David Kirk/NVIDIA and Wen-mei W. Hwu, ECE408, University of Illinois, Urbana-Champaign 1 Programming Massively Parallel Processors Chapter.
Files. System Calls for File System Accessing files –Open, read, write, lseek, close Creating files –Create, mknod.
Status – Week 247 Victor Moya. Summary Streamer. Streamer. TraceDriver. TraceDriver. bGPU bGPU Signal Traffic Analyzer. Signal Traffic Analyzer.
Status – Week 243 Victor Moya. Summary Current status. Current status. Tests. Tests. XBox documentation. XBox documentation. Post Vertex Shader geometry.
Status – Week 231 Victor Moya. Summary Primitive Assembly Primitive Assembly Clipping triangle rejection. Clipping triangle rejection. Rasterization.
Status – Week 242 Victor Moya. Summary Current status. Current status. Tests. Tests. XBox documentation. XBox documentation. Post Vertex Shader geometry.
Status – Week 277 Victor Moya.
GPU Simulator Victor Moya. Summary Rendering pipeline for 3D graphics. Rendering pipeline for 3D graphics. Graphic Processors. Graphic Processors. GPU.
Status – Week 230 Victor Moya. Summary Simulator parameters. Simulator parameters. Oclusion culling (Z-Buffer). Oclusion culling (Z-Buffer). To be done.
Status – Week 248 Victor Moya. Summary Streamer. Streamer. TraceDriver. TraceDriver. bGPU bGPU Signal Traffic Analyzer. Signal Traffic Analyzer. How to.
Status – Week 265 Victor Moya. Summary ShaderEmulator ShaderEmulator ShaderFetch ShaderFetch ShaderDecodeExecute ShaderDecodeExecute Communication storage.
Status – Week 226 Victor Moya. Summary Recursive descent. Recursive descent. Hierarchical Z Buffer. Hierarchical Z Buffer.
Status – Week 272 Victor Moya. Vertex Shader VS 2.0+ (NV30) based Vertex Shader model. VS 2.0+ (NV30) based Vertex Shader model. Multithreaded?? Implemented.
Status – Week 255 Victor Moya. Summary Command Processor. Command Processor. Memory Controller. Memory Controller. Streamer. Streamer. Vertex buffers.
Status – Week 283 Victor Moya. 3D Graphics Pipeline Akeley & Hanrahan course. Akeley & Hanrahan course. Fixed vs Programmable. Fixed vs Programmable.
The programmable pipeline Lecture 10 Slide Courtesy to Dr. Suresh Venkatasubramanian.
Status – Week 207 Victor Moya. Summary Z Test box. Z Test box. Z Compression. Z Compression. Z Cache. Z Cache. Stencil. Stencil. HZ Box. HZ Box. HZ Test.
Status – Week 252 Victor Moya. Summary Command Processor. Command Processor. Memory Controller. Memory Controller. Streamer. Streamer. Rasterizer. Rasterizer.
CS 7810 Lecture 9 Effective Hardware-Based Data Prefetching for High-Performance Processors T-F. Chen and J-L. Baer IEEE Transactions on Computers, 44(5)
Status – Week 260 Victor Moya. Summary shSim. shSim. GPU design. GPU design. Future Work. Future Work. Rumors and News. Rumors and News. Imagine. Imagine.
Status – Week 245 Victor Moya. Summary Streamer Streamer Creditos investigación. Creditos investigación.
Status – Week 266 Victor Moya. Summary ShaderEmulator ShaderEmulator ShaderFetch ShaderFetch ShaderDecodeExecute ShaderDecodeExecute Communication storage.
Buffer Objects Kurt Akeley, NVIDIA Corporation. Outline Background Buffer Objects Vertex Arrays Examples.
Sprite Batching and Texture Atlases Randy Gaul. Overview Batches Sending data to GPU Texture atlases Premultiplied alpha Note: Discussion on slides is.
CSE333 SECTION 7. Midterm Debrief Hex View 1. Find a hex editor. 2. Learn ‘goto offset’ command. 3. See HW3 pictures. The header: Magic word Checksum.
REAL-TIME VOLUME GRAPHICS Christof Rezk Salama Computer Graphics and Multimedia Group, University of Siegen, Germany Eurographics 2006 Real-Time Volume.
OpenGL 3.0 Texture Arrays Presentation: Olivia Terrell, Dec. 4, 2008.
Introduction to CUDA (1 of 2) Patrick Cozzi University of Pennsylvania CIS Spring 2012.
1-1 NET+OS Software Group Flash API Multiple flash memory bank support New Flash API introduction Detailed Flash API Function presentation Supporting.
Ethernet Driver Changes for NET+OS V5.1. Design Changes Resides in bsp\devices\ethernet directory. Source code broken into more C files. Native driver.
CacheLab Recitation 7 10/8/2012. Outline Memory organization Caching – Different types of locality – Cache organization Cachelab – Tips (warnings, getopt,
OpenGL Buffer Transfers Patrick Cozzi University of Pennsylvania CIS Spring 2012.
OpenGL Shader Language Vertex and Fragment Shading Programs.
Xbox MB system memory IBM 3-way symmetric core processor ATI GPU with embedded EDRAM 12x DVD Optional Hard disk.
NVIDIA OpenGL Update Simon Green. Copyright © NVIDIA Corporation 2004 Overview SLI How it works OpenGL Programming Tips SLI Futures New extensions NVX_instanced_arrays.
CSE 381 – Advanced Game Programming GLSL. Rendering Revisited.
11 Intro to cache memory Kosarev Nikolay MIPT Nov, 2009.
© David Kirk/NVIDIA and Wen-mei W. Hwu, ECE408, University of Illinois, Urbana-Champaign 1 Programming Massively Parallel Processors Lecture.
Ray Tracing using Programmable Graphics Hardware
What are shaders? In the field of computer graphics, a shader is a computer program that runs on the graphics processing unit(GPU) and is used to do shading.
Details of Texture Mapping Glenn G. Chappell U. of Alaska Fairbanks CS 381 Lecture Notes Monday, December 1, 2003.
OpenGL Shading Language
Pointer Lecture 2 Course Name: High Level Programming Language Year : 2010.
Programming with OpenGL Part 3: Shaders Ed Angel Professor of Emeritus of Computer Science University of New Mexico 1 E. Angel and D. Shreiner: Interactive.
GLSL Review Monday, Nov OpenGL pipeline Command Stream Vertex Processing Geometry processing Rasterization Fragment processing Fragment Ops/Blending.
COMP 175 | COMPUTER GRAPHICS Remco Chang1/XX13 – GLSL Lecture 13: OpenGL Shading Language (GLSL) COMP 175: Computer Graphics April 12, 2016.
Real-Time Rendering Buffers in OpenGL 3.3
Graphics on GPU © David Kirk/NVIDIA and Wen-mei W. Hwu,
Real-Time Rendering Geometry and Buffers
Geb Thomas Adapted from the OpenGL Programming Guide
Introduction to geometry instancing
Computer Graphics Practical Lesson 8
Programming with OpenGL Part 3: Shaders
Mickaël Sereno Shaders Mickaël Sereno 25/04/2019 Mickaël Sereno -
CS 480/680 Computer Graphics GLSL Overview.
CS 480/680 Part 1: Model Loading.
Opengl implementation
Computer Graphics Vertex Array Object
CS 480/680 Fall 2011 Dr. Frederick C Harris, Jr. Computer Graphics
CIS 6930: Chip Multiprocessor: GPU Architecture and Programming
Presentation transcript:

Status – Week 254 Victor Moya

Summary Command Processor. Command Processor. Memory Controller. Memory Controller. Streamer. Streamer. Vertex buffers in OpenGL. Vertex buffers in OpenGL. ARB_vertex_buffer_object. ARB_vertex_buffer_object.

Command Processor Memory Controller Streamer Vertex Shader CommProcMemoryWrite CommProcMemoryRead StreamerMemoryReq StreamerMemoryReadStreamerCrontrol StreamerState ShaderStateShaderCommand

Vertex Shader Command Processor CommShaderCommand CommShaderState Rasterizer (Fake) ShaderOutput ConsumerState RasterizerCommand RasterizerState

Memory Controller MemoryModule Rasterizer (Fake) RastMemoryRead RastMemoryRequest

Command Processor Stores all GPU state (debug?). Stores all GPU state (debug?). Receives data from AGP and sends it to the Memory Controller. Receives data from AGP and sends it to the Memory Controller. Receives state changes and sends them to the GPU units. Receives state changes and sends them to the GPU units. Receives commands and issues them to the GPU units. Receives commands and issues them to the GPU units.

Command Processor Missing some comunication code with the other units (shaders, rasterizer). Missing some comunication code with the other units (shaders, rasterizer). Missing commands to other units. Missing commands to other units. Missing code for some states. Missing code for some states. Missing AGP_READ and AGP_REG_READ (not useful right now). Missing AGP_READ and AGP_REG_READ (not useful right now).

Memory Controller Access to memory modules => Signal. Access to memory modules => Signal. To decide: number of transactions in process at the same time. To decide: number of transactions in process at the same time. Currently only one transaction at a time. Currently only one transaction at a time. Support multiple modules and multiple banks per module. Support multiple modules and multiple banks per module.

Streamer Two modes: Two modes: Streaming mode. Streaming mode. Index based streaming mode. Index based streaming mode. Streaming mode: Streaming mode: 1) get data for each active attribute. 1) get data for each active attribute. 2) store vertex input data in the FIFO. 2) store vertex input data in the FIFO. 3) send vertex input to a vertex shader. 3) send vertex input to a vertex shader. 4) repeat until end. 4) repeat until end.

Streamer Index based streaming mode: Index based streaming mode: 1) get index data. 1) get index data. 2) get vertex attribute data using index information. 2) get vertex attribute data using index information. 3) store vertex input in FIFO. 3) store vertex input in FIFO. 4) send vertex input to vertex shader. 4) send vertex input to vertex shader. 5) repeat until end. 5) repeat until end.

Streamer Accessing to attribute data in stream mode: Accessing to attribute data in stream mode: Direct access. Direct access. Double buffer (pipelined: read first, process first/read second, read first/process second). Double buffer (pipelined: read first, process first/read second, read first/process second). Accessing to attribute data in index mode: Accessing to attribute data in index mode: Attribute buffer could work like a cache? Attribute buffer could work like a cache? Number of attributes per ‘cache line’. Number of attributes per ‘cache line’. Replacement policy. Replacement policy.

Streamer from Memory Controller Attribute Buffers (16?) Vertex Input Vertex FIFO to Vertex Shader Index Buffer

Vertex Arrays in OpenGL Array definition functions: Array definition functions: VertexPointer(int size, enum type, sizei stride, void *pointer). VertexPointer(int size, enum type, sizei stride, void *pointer). NormalPointer(enum type, sizei stride, void *pointer). NormalPointer(enum type, sizei stride, void *pointer). ColorPointer(int size, enum type, sizei stride, void *pointer). ColorPointer(int size, enum type, sizei stride, void *pointer). SecondaryColorPointer(int size, enum type, sizei stride, void *pointer). SecondaryColorPointer(int size, enum type, sizei stride, void *pointer). IndexPointer(enum type, sizei stride, void *pointer). IndexPointer(enum type, sizei stride, void *pointer). FogCoordPointer(enum type, sizei stride, void *pointer). FogCoordPointer(enum type, sizei stride, void *pointer). TexCoordPointer(int size, enum type, sizei stride, void *pointer). TexCoordPointer(int size, enum type, sizei stride, void *pointer). EdgeFlagPointer(sizei stride, void *pointer). EdgeFlagPointer(sizei stride, void *pointer). VertexAttribPointerARB(uint index, int size, enum type, boolean normalized, sizei stride, const void *pointer). VertexAttribPointerARB(uint index, int size, enum type, boolean normalized, sizei stride, const void *pointer). InterleavedArrays(enum format, sizei stride, void *pointer). InterleavedArrays(enum format, sizei stride, void *pointer).

Vertex Arrays in OpenGL Array drawing functions: Array drawing functions: DrawArrays(enum mode, int first, sizei count). DrawArrays(enum mode, int first, sizei count). MultiDrawArrays(enum mode, int *first, sizei *count, sizei primcount). MultiDrawArrays(enum mode, int *first, sizei *count, sizei primcount). DrawElements(enum mode, sizei count, enum type, void *indices). DrawElements(enum mode, sizei count, enum type, void *indices). MultiDrawElements(enum mode, sizei *count, enum type, void **indices, sizei primcount). MultiDrawElements(enum mode, sizei *count, enum type, void **indices, sizei primcount). DrawRangeElements(enum mode, uint start, unit end, sizei count, enum type, void *indices). DrawRangeElements(enum mode, uint start, unit end, sizei count, enum type, void *indices).

ARB_vertex_buffer_object BindBufferARB(enum target, uint buffer). BindBufferARB(enum target, uint buffer). DeleteBuffersARB(sizei n, const uint *buffers). DeleteBuffersARB(sizei n, const uint *buffers). GenBuffersARB(sizei n, uint *buffers). GenBuffersARB(sizei n, uint *buffers). boolean IsBufferARB(uint buffer). boolean IsBufferARB(uint buffer). BufferDataARB(enum target, sizeiptrARB size, const void *data, enum usage). BufferDataARB(enum target, sizeiptrARB size, const void *data, enum usage). BufferSubDataARB(enum target, intptrARB offset, sizeiptrARB size, const void *data). BufferSubDataARB(enum target, intptrARB offset, sizeiptrARB size, const void *data). GetBufferSubDataARB(enum target, intptrARB offset, sizeiptrARB size, void *data). GetBufferSubDataARB(enum target, intptrARB offset, sizeiptrARB size, void *data). void *MapBufferARB(enum target, enum access). void *MapBufferARB(enum target, enum access). boolean UnMapBufferARB(enum target). boolean UnMapBufferARB(enum target).

ARB_vertex_buffer_object target: target: ARRAY_BUFFER_ARB. ARRAY_BUFFER_ARB. ELEMENT_ARRAY_BUFFER_ARB. ELEMENT_ARRAY_BUFFER_ARB. usage: usage: STREAM_DRAW_ARB STREAM_DRAW_ARB STREAM_READ_ARB STREAM_READ_ARB STREAM_COPY_ARB STREAM_COPY_ARB STATIC_DRAW_ARB STATIC_DRAW_ARB STATIC_READ_ARB STATIC_READ_ARB STATIC_COPY_ARB STATIC_COPY_ARB DYNAMIC_DRAW_ARB DYNAMIC_DRAW_ARB DYNAMIC_READ_ARB DYNAMIC_READ_ARB DYNAMIC_COPY_ARB DYNAMIC_COPY_ARB

ARB_vertex_buffer_object access: access: READ_ONLY_ARB. READ_ONLY_ARB. WRITE_ONLY_ARB. WRITE_ONLY_ARB. READ_WRITE_ARB. READ_WRITE_ARB.