With more workstation applications utilizing more efficient rendering pipelines and rendering larger scenes with more complex fragment shaders, GPUs can become the bottleneck in a system. The first part of this talk will be a refresher on multi-gpu programming basics to scale your rendering tasks. We show how to target individual APIs programmatically as well as structure your application by using multiple threads, OpenGL contexts and handle the synchronization and data transfer. The second part will dive in to details of designing a rendering pipeline that can efficiently utilize a multi-GPU setup by splitting rendering tasks into a set of phases. These phases represent a set of threads that distribute the rendering load across a set of GPUs. The talk will comprise how to set up a multithreaded application using C++11 constructs, how to analyze/debug the performance of a graphics application, how to do PCIe transfers efficiently and how to optimally distribute workload across different GPUs.
Workstation applications today demand a tightly coupled compute-graphics pipeline where the simulation and the graphics are done interactively and in parallel. The use of multiple GPUs provides an affordable way for such applications to improve their performance and increase their useable data size by partitioning the processing and subsequent visualization among mulitple GPUs. This tutorial explains the methodologies of how to program your application for a multi-GPU environment. Part 2 of this tutorial will cover programming methodologies, including: How to structure an application to optimize compute and graphics performance and manage synchronization; How to manage data transfers across the PCIE bus; Debugging and profiling; Programming considerations when scaling beyond two GPUs - multiple compute GPUs feeding to one or multiple graphics GPUs. Throughout this tutorial, simple OpenGL and CUDA examples designed for a single GPU will be modified to efficiently work in a multi-GPU environment.
The goal of this session is to explain the major methods a workstation developer would use to mix and adopt OpenGL and CUDA architecture to build (or improve) a high performance workstation application. This talk/demo would walk through the major concepts that utilize the Quadro (and Tesla) hardware (Multi-GPU programming, OpenGL/CUDA interop, CUDA streaming, and dual copy engines). At the end of this session, the developer will have a solid understanding of ï key concepts behind multi-GPU programming (including maximus configurations) ï features of OpenGL and CUDA that support multi-GPU programming and in which development environments (ie linux vs windows OpenGL vs directX) ï differentiating features of high-end Quadro/Tesla boards like Dual Copy Engines and when to take advantage of them. ï how to get started with GPU Accelerated software development
This talk will describe how to scale up from one to many displays for high end visualization. You will learn about NVIDIA's new Warp and Blend capability that allows you to create a truly seamless logical display comprised of many individual display outputs. With this new capability you can project your graphics onto curved surfaces and implement the correct transformation entirely on the GPU without any external hardware to get the correct display transformations.
Learn how you can use a multiple display configuration to render video content captured from multiple sources, utilizing the power of GPUs to achieve unprecedented performance.
Multi-GPU configurations are becoming common affordable options for OpenGL applications to scale performance, data size, display size and image quality. We show how to structure your application for multi-gpu rendering by using multiple threads and OpenGL contexts and handle the synchronization and data transfer. We conclude with a discussion of how to implement common parallel rendering approaches such as sort-first, sort-last and hybrid techniques.
Many real world graphics applications need to transfer textures efficiently in and out of GPU memory in the form of 2D images, 2.5D terrains or 3D volumes as well as their time-varying counterparts. The first part of this talk covers technical pointers on how to optimize your OpenGL application to overlap transfers with rendering using the NVIDIA Copy Engines. The second part demonstrates the integration and performance of this feature within the a real world latency-sensitive broadcast graphics application from VizRT.
Join NVIDIA product manager and application engineers for multi-display systems for an interactive discussion on the current trends in video walls, blended multi-projector systems and its deployment.
With advances in image acquisition and numerical simulation techniques, fields ranging from medical imaging to astrophysics are producing data with very large spatial and temporal resolutions. Interactive visualization techniques are crucial to understand and isolate features from the resulting large time dependent 4D volumetric data. This presentation explores the various rendering methods such as texture slicing, raycasting in graphics and cuda as well as hybrid approaches showing their promises and pitfalls. It is common for 4D data to exceed the graphics memory capabilities and approaches for efficiently streaming data such as PBO's and CPU/GPU asynchronous modes are explained. We conclude with a discussion on how other related solutions from NVIDIA can be integrated, specifically focusing on 3D Vision stereo and NVScale middleware to harness multiple GPU's for distributed rendering.