Nvidia Corporation

Hewlett-Packard Development Company, L.p.

Barthold B Lichtenbelt

Patrick Richard Brown

Christopher T Dodd

Mark J Kilgard

Jeffrey A Bolz

Ross Cunniff

Jeffrey F Juliano

Franck Diard

Eric Sovelen Werness

Simon G Green

Mark J Harris

Ralf Biermann

Hasan Shahzad Naqvi

Nicholas Bennett Carter

Jeff William Burrell

One embodiment of the present invention sets forth a set of application programming interface (API) extensions that enable a software application to control the processing work assigned to each GPU in a multi-GPU system. The software application enumerates a list of available GPUs, sets an affinity mask from the enumerated list of GPUs and generates an affinity device context associated with the affinity mask. The software application can then generate and utilize an affinity rendering context that directs rendering commands to a set of explicitly selected GPUs, thus allocating work among specifically selected GPUs. The software application is empowered to use domain specific knowledge to better optimize the work assigned to each GPU, thus achieving greater overall processing efficiency relative to the prior art techniques.

Using affinity masks to control multi-GPU processing

One embodiment of the present invention sets forth a system configured for transferring data between independent application programming interface (API) contexts on one or more graphics processing units (GPUs). Each API context may derive from an arbitrary API. Data is pushed from one API context to another API context using a peer-to-peer buffer 'blit' operation executed between buffers allocated in the source and target API context memory spaces. The source and target API context memory spaces may be located within the frame buffers of the source and target GPUs, respectively, or located within the frame buffer of a single GPU. The data transfers between the API contexts are synchronized using semaphore operator pairs inserted in push buffer commands that are executed by the one or more GPUs.

System and method for transferring data between unrelated API contexts on one or more GPUs

One embodiment of the present invention sets forth a technique for improving the flexibility and programmability of a graphics pipeline by adding application programming interface (API) extensions to the OpenGL Shading Language (GLSL) that provide native support for integer data types and operations. The integer API extensions span from the API to the hardware execution units within a graphics processing unit (GPU), thereby providing native integer support throughout the graphics pipeline.

Integer-based functionality in a graphics shading language

A method and apparatus for distributing the workload of rendering an image where texture mapping is involved among multiple graphics processing units (GPUs) are provided. The method generally entails dividing a texture map among multiple GPUs, performing texture mapping in each GPU to render image data in each GPU's frame buffer, combining the image data from each frame buffer, and scanning out the combined image to a display.

Distributed rendering of texture data

Methods and systems for processing a geometry shader program developed in a high-level shading language are disclosed. Specifically, in one embodiment, after having received the geometry shader program configured to be executed by a first processing unit in a programmable execution environment, the high-level shading language instructions of the geometry shader program is converted into low-level programming language instructions. The low-level programming language instructions are then linked with the low-level programming language instructions of a domain-specific shader program, which is configured to be executed by a second processing unit also residing in the programmable execution environment. The linked instructions of the geometry shader program are directed to the first processing unit, and the linked instructions of the domain-specific shader program are directed to the second processing unit.

Methods and systems for processing a geometry shader program developed in a high-level shading language

One embodiment of the invention is a method for storing transformed vertex attributes that includes the steps of allocating memory space for a transform feedback buffer, selecting one or more transformed vertex attributes to store in the transform feedback buffer independently of any shader programs executing on any processing units in the graphics rendering pipeline, configuring the transform feedback buffer to store the one or more transformed vertex attributes, and initiating a processing mode wherein vertex data is processed in the graphics rendering pipeline to produce the transformed vertices, the attributes of which are then written to the transform feedback buffer. One advantage is that the transform feedback buffer can be used to store and access transformed vertices, without having to convert the vertex data to a pixel format, store the pixels in a frame buffer, and then convert the pixels back to a vertex format.

Feedback and record of transformed vertices in a graphics library

One embodiment of the invention is a method of accessing a bindable uniform variable bound to a buffer object that includes the steps of creating a linked program object comprising one or more shader programs, where each shader program includes instructions written in a high-level shader language, and where the linked program object includes a reference to a bindable uniform variable and indicates which shader programs use the bindable uniform variable. The method also includes determining a memory size to support the bindable uniform variable, allocating a buffer object having the memory size, binding the buffer object to the bindable uniform variable, populating the buffer object with values for the bindable uniform variable, and accessing the values of the bindable uniform with one or more of the shader programs in the linked program object.

Storage and support for large amounts of constant data in a graphics library

A voxel transfer circuit that implements high-speed voxel transfer operations. When implemented in a 2D or 3D texture mapping circuit of a graphics system, or in a graphics card adapter of a workstation, the voxel transfer circuit provides a comprehensive, accelerated volume rendering capability to the existing imaging pipeline. For each voxel in a volume data set, the voxel transfer circuit generates a texel having an opacity value and a color value based on one or more properties of the voxel including the local gradient magnitude and a lighting model. The relationship between these values is referred to herein as a classification or transfer function. In the present invention, the voxel transfer circuit implements a transfer function that employs a gradient-influenced classification. Such a transfer function generates opacity and color values of structures with excellent edge and surface discrimination. Preferably the voxel transfer circuit also includes the influence of a lighting model on the voxel, providing improved three-dimensional clarity and depth cues. As a result, the present invention enables existing systems to perform complete volume rendering at accelerated texture mapping speeds. Thus, the invention allows for modifications to the parameters used during the voxel transfer process, enabling the operator to interactively modify the results of the volume rendering operations at accelerated rates. This allows graphics applications to expand the use of volume rendering while also providing operators with the ability to interactively explore different ways of visualizing their 3D volume data. Thus, the present invention enables the operator to re-render the voxel repeatedly, gradually modifying the transfer function in small increments and view the results of the modification in a sequence of volume-rendered frames that are rendered quickly.

Growing community of inventors

Fort Collins, CO, United States of America

Barthold B Lichtenbelt