# Patent

## Title
Configuring resources used by a graphics processing unit

## Abstract

A resource used by a shader executed by a graphics processing unit is referenced using a “descriptor”. Descriptors are grouped together in memory called a descriptor heap. Applications allocate and store descriptors in descriptor heaps. Applications also create one or more descriptor tables specifying a subrange of a descriptor heap. To bind resources to a shader, descriptors are first loaded into a descriptor heap. When the resources are to be used by a set of executing shaders, descriptor tables are defined on the GPU identifying ranges within the descriptor heap. Shaders, when executing, refer to the currently defined descriptor tables to access the resources made available to them. If the shader is to be executed again with different resources, and if those resources are already in memory and specified in the descriptor heap, then the descriptor tables are changed to specify different ranges of the descriptor heap.

## Background
CROSS REFERENCE TO RELATED APPLICATIONS
This application is a non-provisional application of U.S. Provisional Patent Application Ser. No. 61/955,715, filed Mar. 19, 2014, hereby incorporated by reference.
BACKGROUND
In many computer systems, a graphics processing unit is provided as a coprocessor to a central processing unit. The graphics processing unit is specially designed to handle certain kinds of operations efficiently, particularly manipulation of image data and data describing three-dimensional structures. Computer programs running on such computer systems are written to take advantage of the graphics processing unit by specifying operations to be performed by the graphics processing unit and the resources, such as image data, textures and other data structures or data, to be used in those operations.
Operations are generally implemented as computer programs, typically called “shaders”, in a language recognized by the graphics processing unit, typically called a “shader language”. The act of instructing the graphics processing unit what resource a shader uses is called “binding” the resource to that shader. An application programming interface for the computer system generally provides a layer of abstraction through which computer programs access and configure the graphics processing unit.
Although the graphics processing unit executes the specified shaders using the resources bound to those shaders, the central processing unit configures the graphics processing unit by loading the shaders and resources into memory, and binding the resources to the shaders. Generally, such configuration is performed for each operation, i.e., shader, to be processed by the graphics processing unit just before the time that operation is requested to run. The resources used for binding (which are references to the underlying actual data) also are themselves objects that are created and deleted through the operating system, and are tracked when used to manage memory allocation and paging of the underlying resources to which they refer.
Thus, with computer programs that heavily use the graphics processing unit, such as video games, three-dimensional modeling and animation tools, image processing tools, virtual reality applications, scientific and other information visualization applications, flight simulation and the like, the central processing unit experiences significant performance overhead to simply configure the graphics processing unit.
SUMMARY
This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is intended neither to identify key or essential features, nor to limit the scope, of the claimed subject matter.
An application programming interface for a computer system with a graphics processing unit exposes a resource, to be used by a shader executed by the GPU, as a “descriptor” in memory containing a pointer to its location in memory as well as other configuration information, such as data format. Descriptors are grouped together in contiguous locations in memory called a descriptor heap. For example, for each type of resource, descriptors of that type can be grouped together in contiguous locations within the descriptor heap. A descriptor heap can correspond to a collection of descriptors of a single resource type or a mix of resource types that have unified storage. Applications allocate descriptor heaps and store descriptors in the descriptor heaps. Next, to identify what portion of the heap a given shader will access, descriptor tables are created, one or more for each type of resource or set of resource types represented in unified storage. A descriptor table specifies a range within a descriptor heap. Given any configuration of hardware capability and resource types, there will be a maximum supported size of the descriptor heap, a maximum supported size to any descriptor table and a maximum supported number of descriptor tables, thus allowing applications to adapt to the level of capability of any given hardware.
To bind resources to a shader, descriptors are first loaded into one or more descriptor heaps. Such loading can occur any time in advance of the binding. When the resources are to be used by a set of executing shaders, descriptor tables are defined on the GPU identifying ranges within the one or more descriptor heaps. Shaders, when executing, refer to the currently defined descriptor tables to access the resources made available to them. If the shader is to be executed again with different resources, and if those resources are already in memory and specified in the one or more descriptor heaps, then the descriptor tables are changed to specify different ranges of the descriptor heaps.
In the following description, reference is made to the accompanying drawings which form a part hereof, and in which are shown, by way of illustration, specific example implementations of this technique. It is understood that other embodiments may be utilized and structural changes may be made without departing from the scope of the disclosure.



DESCRIPTION OF THE DRAWINGS
FIG. 1 is a block diagram of an example computer including a graphics processing unit.
FIG. 2A is a diagram of software and hardware layers in an example implementation.
FIG. 2B is a diagram of software layers in an example implementation.
FIG. 3 is a diagram of data structures in an example implementation.
FIG. 4 is a flow chart describing an example use of such a system.
FIG. 5 is a flow chart describing another example use of such a system.
FIG. 6 is a flow chart describing another example use of such a system.



DETAILED DESCRIPTION
The following section describes an example computer system implementation that for configuring and managing resources used by a graphics processing unit within the computer system.
Referring to FIG. 1, an example computer in which such techniques can be implemented will now be described. This is only one example of a computer and is not intended to suggest any limitation as to the scope of use or functionality of such a computer. The following description is intended to provide a brief, general description of such a computer. The computer can be any of a variety of general purpose or special purpose computing hardware configurations. Some examples of types of computers that can be used include, but are not limited to, personal computers, game consoles, set top boxes, hand-held or laptop devices (for example, media players, notebook computers, tablet computers, cellular phones, personal data assistants, voice recorders), server computers, multiprocessor systems, microprocessor-based systems, programmable consumer electronics, network PCs, minicomputers, mainframe computers, and distributed computing environments that include any of the above types of computers or devices, and the like.
With reference to FIG. 1, an example computer 100 includes at least one processing unit 102 and memory 104. The computer can have multiple processing units 102. A processing unit 102 can include one or more processing cores (not shown) that operate independently of each other. Additional co-processing units, such as graphics processing unit 120, also can be present in the computer. The memory 104 may be volatile (such as dynamic random access memory (DRAM) or other random access memory device), non-volatile (such as a read-only memory (ROM), flash memory, and the like) or some combination of the two. This configuration of memory is illustrated in FIG. 1 by dashed line 106. The computer 100 may include additional storage (removable and/or non-removable) including, but not limited to, magnetically-recorded or optically-recorded disks or tape. Such additional storage is illustrated in FIG. 1 by removable storage 108 and non-removable storage 110. The various components in FIG. 1 are generally interconnected by an interconnection mechanism, such as one or more buses 630.
A computer storage medium is any medium in which data can be stored in and retrieved from addressable physical storage locations by the computer. Computer storage media includes volatile and nonvolatile memory, and removable and non-removable storage. Memory 104, removable storage 108 and non-removable storage 110 are all examples of computer storage media. Some examples of computer storage media are RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optically or magneto-optically recorded storage device, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices. Computer storage media and communication media are mutually exclusive categories of media.
Computer 100 also can include communications connection(s) 112 that allow the computer to communicate with other devices over a communication medium. Communication media typically transmit computer program instructions, data structures, program modules or other data over a wired or wireless substance by propagating a modulated data signal such as a carrier wave or other transport mechanism over the substance. The term “modulated data signal” means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal, thereby changing the configuration or state of the receiving device of the signal. By way of example, and not limitation, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, radio frequency, infrared and other wireless media. Communications connections 112 are devices, such as a wired network interface, wireless network interface, radio frequency transceiver, e.g., Wi-Fi, cellular, long term evolution (LTE), Bluetooth, etc., transceivers, navigation transceivers, e.g., global positioning system (GPS), Global Navigation Satellite System (GLONASS), etc., that interface with the communication media to transmit data over and receive data from communication media, and may perform various functions with respect to that data.
Computer 100 may have various input device(s) 114 such as a keyboard, mouse, pen, camera, touch input device, sensors (e.g., accelerometers, gyroscopes), and so on. Output device(s) 116 such as a display, speakers, a printer, and so on may also be included. All of these devices are well known in the art and need not be discussed at length here. The input and output devices can be part of a housing that contains the various components of the computer in FIG. 1, or can be separable from that housing and connected to the computer through various connection interfaces, such as a serial bus, wireless communication connection and the like. Various input and output devices can implement a natural user interface (NUI), which is any interface technology that enables a user to interact with a device in a “natural” manner, free from artificial constraints imposed by input devices such as mice, keyboards, remote controls, and the like.
Examples of NUI methods include those relying on speech recognition, touch and stylus recognition, hover, gesture recognition both on screen and adjacent to the screen, air gestures, head and eye tracking, voice and speech, vision, touch, gestures, and machine intelligence, and may include the use of touch sensitive displays, voice and speech recognition, intention and goal understanding, motion gesture detection using depth cameras (such as stereoscopic camera systems, infrared camera systems, and other camera systems and combinations of these), motion gesture detection using accelerometers or gyroscopes, facial recognition, three dimensional displays, head, eye, and gaze tracking, immersive augmented reality and virtual reality systems, all of which provide a more natural interface, as well as technologies for sensing brain activity using electric field sensing electrodes (EEG and related methods).
The various storage 110, communication connections 112, output devices 116 and input devices 114 can be integrated within a housing with the rest of the computer, or can be connected through input-output interface devices on the computer, in which case the reference numbers 110, 112, 114 and 116 can indicate either the interface for connection to a device or the device itself as the case may be.
Each component (which also may be called a “module” or “engine” or “library” or the like) of a system such as described in FIGS. 2-6 below, and which operates on a computer, can be implemented using the one or more processing units of one or more computers and one or more computer programs processed by the one or more processing units. A computer program includes computer-executable instructions and/or computer-interpreted instructions, such as program modules or libraries, which instructions are processed by one or more processing units in one or more computers. Generally, such instructions define routines, programs, objects, components, data structures, and so on, that, when processed by a processing unit, instruct the processing unit to perform operations on data, or configure the one or more processing units to implement various components or data structures. Such components have inputs and outputs by accessing data in storage or memory and by storing data in storage or memory.
This computer system may be practiced in distributed computing environments where operations are performed by multiple computers that are linked through a communications network. In a distributed computing environment, computer programs may be located in both local and remote computer storage media.
Alternatively, or in addition, the functionality of one or more of the various components described herein can be performed, at least in part, by one or more hardware logic components. For example, and without limitation, illustrative types of hardware logic components that can be used include Field-programmable Gate Arrays (FPGAs), Program-specific Integrated Circuits (ASICs), Program-specific Standard Products (ASSPs), System-on-a-chip systems (SOCs), Complex Programmable Logic Devices (CPLDs), etc.
Given a computer such as described in FIG. 1, an application programming interface is provided to allow computer programs written for the computer to take advantage of the graphics processing unit. Referring to FIG. 2A, the software and hardware layers in such a computer system are illustrated. Access to the resources of the central processing unit 200, graphics processing unit 202 and memory 204 are managed by an operating system 206. Examples of commercially available operating systems include Windows from Microsoft Corporation, iOS and OS X from Apple Computer and Android from Google.
The memory resources represented by memory 204 in FIG. 2A can be implemented using any of a variety of memory architectures. For example, a computer system can have video memory used by the GPU and separate system memory used by the CPU. A computer system can have a unified memory that is shared by both the GPU and the CPU. The memory also can include one or more layers of caching. Applications access these various memory resources through the operating system. The various data structures described below, such as descriptors and descriptor heaps, can be stored in any memory resource depending on desired performance characteristics.
The operating system supports an application programming interface 208 which abstracts specific details of the implementation of the hardware from application 210. Applications 210, such as a game engine or animation tool, utilize the software interface provided by the API layer 208 to access the GPU, CPU and memory resources. Examples of commercially available API layers are the OpenGL interface from Khronos Group and the Direct3D interface from Microsoft Corporation.
Such API layers generally are implemented using, as shown in FIG. 2B, a user mode level graphics library 240, having an application programming interface 242 for applications, and a graphics kernel 260, resident in the kernel of the operating system. Operations in the graphics library 240 access the graphics kernel through a user mode graphics interface 244, which communicates with the operating system kernel driver 262 which controls a graphics kernel 260 to manipulate the graphics processing hardware.
The application programming interface 208 decouples the tasks of making of resources resident in memory from the tasks of binding resources to shaders. Various tasks related to object lifetime management and synchronization of access to resources by the CPU and GPU are expected to be handled by the application.
The application programming interface exposes a resource, to be used by a shader executed by the GPU, as a “descriptor” in memory containing a pointer to its location in memory as well as other configuration information, such as data format. Descriptors are grouped together in contiguous locations in memory called a descriptor heap. For example, for each type of resource, descriptors of that type can be grouped together in contiguous locations within the descriptor heap. A descriptor heap can correspond to a collection of descriptors of a single resource type or a mix of resource types that have unified storage. Applications allocate descriptor heaps and store descriptors in the descriptor heaps. Next, to identify what portion of the heap a given shader will access, descriptor tables are created, one or more for each type of resource or set of resource types represented in unified storage. A descriptor table specifies a range within a descriptor heap. Given any configuration of hardware capability and resource types, there will be a maximum supported size of the descriptor heap, a maximum supported size to any descriptor table and a maximum supported number of descriptor tables, thus allowing applications to adapt to the level of capability of any given hardware.
To bind resources to a shader, descriptors are first loaded into one or more descriptor heaps. Such loading can occur any time in advance of the binding. When the resources are to be used by a set of executing shaders, descriptor tables are defined on the GPU identifying ranges within the one or more descriptor heaps. Shaders, when executing, refer to the currently defined descriptor tables to access the resources made available to them. If the shader is to be executed again with different resources, and if those resources are already in memory and specified in the one or more descriptor heaps, then the descriptor tables are changed to specify different ranges of the descriptor heaps.
Thus, the application programming interface allows an application to create and load descriptors, descriptor heaps and descriptor tables to be associated with shaders executed on the GPU.
Referring now to FIG. 3, the data structures for the descriptor, descriptor heap and descriptor table will now be described in more detail.
A descriptor 300 is a small block of data that describes, whether fully or partially, an object to the GPU. There are many types of descriptors, with a descriptor format for each type of object or resource to be used by the GPU. Some examples of types of resources for which there is a descriptor include the following: index buffer, vertex buffer, shader resource, constant buffer, sampler, unordered access, stream output, render target and depth stencil. Descriptor size is specific to the hardware using the descriptors; the following example implementation assumes a descriptor size of about 64 bytes or less.
An application programming interface can be designed to provide direct access by applications to descriptor memory. Alternatively, the API can provide more abstract definitions of these resources, and can translate information provided by an application into descriptors, which the API then allocates in descriptor memory.
Descriptors are stored in descriptor heaps. Descriptor heaps have two definitions—one from the perspective of the application programming interface 310, and another from the perspective of the hardware 320 being used.
From the application programming interface point of view, a descriptor heap is a collection of contiguous allocations of descriptor storage. A descriptor heap stores descriptors of a single object type or descriptors of a collection of different object types that can be represented in unified storage. Such allocations are provided for the different object types that are available for applications to use. As an example of a collection of object types represented in unified storage, constant buffers, shader resources and unordered access types of descriptors can be combined in a unified descriptor heap, and thus in a contiguous set of memory locations. In such an implementation, applications can arbitrarily mix descriptors of different types together within the one heap. A single descriptor table can point to a collection of different descriptor types in this set, which the hardware can represent with unified storage (i.e., a contiguous set of memory locations).
From the hardware point of view, a single API descriptor heap can map to multiple hardware heaps, depending on the hardware. GPU hardware differs in the extent to which different resource types share a hardware heap. Generally a hardware descriptor heap is an allocation of a fixed amount of video memory for each type, or collection of types, of resources. Different types may have different heap size limits, and those types that share a heap generally share, in the aggregate, the same heap size limit.
Thus each API descriptor heap 310 spans all object types, with dedicated storage for each type, or collection of types that can be represented in unified storage, indicated as per-type storage 312. A hardware descriptor heap 320 provides dedicated storage for one or more types 322 with specified hardware limits 324, which are specific to any implementation. Through the API, and application sets up descriptor heaps, and the system or GPU driver, depending on the hardware specifications, allocates corresponding hardware descriptor heaps, ensuring that the heaps fall within their heap size limits.
One purpose of a descriptor heap is to encompass a bulk of memory allocation for storing all of the descriptor specifications, of all object types, which an application is using, for as large of a window of rendering as possible, e.g., a frame or more. As described below in connection with descriptor tables, shaders then can be directed to quickly change which sets of descriptors within a descriptor heap are being used, and thus reduce CPU overhead, if the descriptors to be used are all stored in a descriptor heap. Additionally, with multiple API descriptor heaps, if their aggregate size falls within the hardware heap size limits, then the cost of switching between API heaps can be virtually free. Switching hardware heaps on some hardware can require the GPU to retire currently executing work.
Given an allocation of a descriptor heap, an application issues API commands to populate the descriptor heap with object descriptors. Such commands occur in command lists or bundles that are processed by the runtime engine. Each command list has a current descriptor heap as part of its context, which can also be defined through the API by an application. This recording of edits in a command list allows systems with separate CPU memory and GPU memory to ensure that the GPU sees the edits by copying the edits to the GPU as necessary; however, on systems where the CPU and GPU share memory, no copy is needed. The API can also provide an “offline” descriptor heap that is always in CPU memory where applications can freely populate descriptors in a free threaded way. With such an offline descriptor heap, descriptors can be copied to “online” descriptor heaps via command lists or bundles only when needed by the GPU.
To further facilitate the ability to store large descriptor heaps and allow shaders to switch the descriptors currently being used, another data structure called descriptor tables is used. A descriptor table is an array of descriptors of an object type, or collection of object types represented in unified storage, and thus can be defined as a subrange of a descriptor heap. It is possible to define nested descriptor tables, wherein a desired descriptor table is selected by indexing within another descriptor table. The application uses an API construct to define a descriptor table 330 for each resource type, or collection or resource types represented in unified storage. The subrange of the current descriptor heap can be specified in a number of ways, for example by specifying an offset 334 and optional length 336. The length is optional because the hardware can operate without knowledge of an upper bound of the range, as shaders generally access descriptors using offsets from the base offset 334. Similarly, the API specifies a descriptor table 340 to the hardware as an offset 344 and optional length 346 in the corresponding descriptor heap.
The use of descriptors, descriptor heaps and descriptor tables enables a significant reduction in CPU overhead in binding resources to shaders when assigning work to a GPU. The reduction in CPU overhead comes initially through the separation of descriptor heap management from descriptor table management, which allows applications to reduce binding cost. In particular, applications can pre-generate or reuse descriptor heap contents in advance of instructing the GPU to perform work. Thus, when submitting work to a GPU to be performed, the application merely passes on descriptor table(s).
Another benefit of using descriptor tables and descriptor heaps, and in turn a separate descriptor table for each resource type, or collection of resource types represented in unified storage, is that shader programs can be isolated from knowledge of the size and layout of descriptor heaps. An application assembles a collection of different resource types to be referenced by the GPU by creating multiple descriptor tables. The application programming interface and underlying system handles allocating descriptor heaps and storing descriptor objects in response to instructions from the application. The GPU in turn receives information for each resource type about data for that resource type being located at a particular offset and range within a heap.
Similarly, applications can be isolated from knowledge of implementation of the GPU hardware in supporting descriptor heaps for different resource types. The application programming interface allows an application to specify a monolithic descriptor heap, and in turn interfaces with the hardware implementation, which may manage different descriptor heaps for different resource types and/or may combine some resource types into the same descriptor heap in unified storage.
The amount of flexibility available in the descriptor heaps and descriptor tables varies by the level of capability of the GPU, and is supported by the API having API level descriptor heaps and descriptor tables and hardware specific descriptor heaps and descriptor tables, where the API maps between the two. More modern GPUs generally have fewer constraints. For instance, on more modern hardware the maximum size of a descriptor heap increases, the maximum size of a given descriptor table increases, the number of descriptor tables that can be simultaneously active increases, and the level of ability for a shader to dynamically select a resource out of a descriptor table increases. The maximum heap size, maximum descriptor table size, maximum number of descriptor tables and whether dynamic indexing within a descriptor table is supported, are examples of limits of underlying hardware that can be enforced by the application programming interface. This flexibility and enforcement of limits also allows such techniques to be provided by an application programming interface that supports several different hardware platforms.
Commands for recording and issuing tasks for the GPU, which include editing descriptor heaps and descriptor tables and defining command lists, can also be recorded/issued by multiple CPU threads in parallel. Thus, applications can operate on different regions of a heap simultaneously. So in addition to CPU-GPU parallelism, parallelism across CPU threads also works efficiently with respect to binding management.
The separation of descriptor heap management from descriptor table management also supports multiple different kinds of uses.
As one example, if an application is rapidly switching between sets of descriptors which are being generated by the CPU while the application is submitting work to the GPU, the aggregate set of descriptors referenced by all the submitted work can be spread out into unique locations in the descriptor heap. The GPU can proceed to reference some parts of the descriptor heap even as the application is preparing future work by configuring other parts of the descriptor heap. Thus, as shown in FIG. 4, the application allocates 400 a descriptor heap, and then loads 402 a first set of descriptors into a first part of the descriptor heap. A descriptor table corresponding to the first set of descriptors is defined 404. Next, the GPU is instructed 406 to perform work according to the specified descriptor table referencing descriptors in the descriptor heap. While the first set of work has been recorded for execution or is being performed 410 by the GPU, the application generates and loads 408, in parallel, another set of descriptors into another part of the descriptor heap, specified by another descriptor table. After the GPU completes a current set of work and more descriptors are loaded into the descriptor heap, a different descriptor table can be provided to the GPU to instruct 406 the GPU to perform 410 another set of work. This process can repeat with the GPU performing 410 work in parallel with the CPU loading 408 additional descriptors and defining another descriptor table for the next set of work to be performed by the GPU.
As another example, an application can prepare all of the descriptors in the descriptor heap ahead of time. Then, a descriptor table can be set of a relevant small area of the descriptor heap for each individual work item. That work item then can be submitted. The process then repeats for each individual work item. Thus, as shown in FIG. 6, the application allocates 600 a descriptor heap, then loads 602 all descriptors into the descriptor heap. A descriptor table corresponding to a first set of descriptors is defined 604. Next, the GPU is instructed 606 to perform work according to the specified descriptor table referencing descriptors in the descriptor heap. While the first set of work has been recorded for execution or is being performed 610 by the GPU, the application can specify 608, in parallel, another descriptor table for another part of the descriptor heap. After the GPU completes a current set of work, a different descriptor table can be provided to the GPU to instruct 606 the GPU to perform 610 another set of work. This process can repeat with the GPU performing 610 work in parallel with the CPU specifying 608 additional work with other descriptor tables for the next set of work to be performed by the GPU.
As another example, if an application is written so that shaders executing on the GPU are able to select from a large collection of resources on the fly, the application can put 500 all descriptors into a descriptor heap, set 502 a large descriptor table covering the large range. The shader then can dynamically select 504 any resource(s) out of the descriptor table, and then performs 506 its work. After completing processing using that selection, it can select any other resources using the descriptor table.
All of the foregoing scenarios can be supported within the same application, or even simultaneously for different resource types. For example, an application might have a global set of resources that never changes that can be left permanently bound via one descriptor table, while another set of resources switches frequently and can be served by a set of separate descriptor tables that change at the desired frequency.
In some implementations, the GPU supports receiving, and the API provides a mechanism for delivering sets of per-command constants, herein called “pipelined constants”. To help applications more easily drive dynamic selection of resources or data within resources from shaders, applications can pass pipelined constants to shaders directly from the CPU when Draw/Dispatch commands are issued. Pipelined constants can be used to provide additional application-defined values to shaders. Such an implementation can be supported by adding parameters to Draw/Dispatch APIs to allow for additional values, or by adding an additional mechanism to the API to allow applications to define a set of “pipelined constants”.
While applications can use constant buffer resources as described above to pass constants to shaders, pipelined constants instead use small amounts of existing storage that the majority of GPUs already have available for pipelining state changes as GPU work is being submitted. For example, pipelined constants can be stored by GPU drivers in the same small storage area that descriptor table settings are stored.
An example use of pipelined constants is to allow an application to provide offsets that can be combined with existing VertexID and InstanceID counters that the pipeline provides to shaders automatically to help each shader invocation identify itself (and thus know what its task is, as distinct from other shaders). Having a small number of pipelined constants available can also significantly reduce pressure on descriptor heap storage. Particularly, every time a pipelined constant can handle a small amount of data that is changing at a high frequency, such as an instance seed value that the application uses to drive what all the shader work will do, one less descriptor heap slot and descriptor table setting are done.
Any or all of the aforementioned alternate embodiments described herein may be used in any combination desired to form additional hybrid embodiments. It should be understood that the subject matter defined in the appended claims is not necessarily limited to the specific implementations described above. The specific implementations described above are disclosed as examples only.

## Claims

1. A computer system, comprising:
a central processing unit;
a graphics processing unit;
memory accessible by the graphics processing unit during execution of commands;
the central processing unit executing an operating system that manages access, by applications running on the central processing unit, to resources in the computer system including the graphics processing unit and memory,
wherein the operating system provides an application programming interface managing execution of commands by the graphics processing unit and through which the applications running on the central processing unit specify, through a runtime engine, commands to the graphics processing unit,
wherein the application running on the central processing unit is operative at runtime to specify commands through the application programming interface including commands specifying shaders to be executed by the graphics processing unit and resources to be used by the shaders,
wherein at runtime the graphics processing unit is operative to execute the shaders using the resources specified by the commands from the application, using descriptors stored in the memory to access the resources, wherein the descriptors are stored in one or more descriptor heaps in the memory, and
wherein the commands from the application through the application programming interface specify the resources to be used by the shaders by indicating one or more descriptor tables, wherein a descriptor table specifies a range within the one or more descriptor heaps storing the descriptors for the resources to be accessed.

2. The computer system of claim 1, wherein:
the application programming interface first receives from applications descriptor heap contents in advance of instructing the graphics processing unit to perform work; and
the application programming interface second receives an instruction from the application including one or more descriptor tables instructing the GPU to perform work using the descriptors referenced by the one or more descriptor tables.

3. The computer system of claim 1, wherein an application configures a descriptor heap, loads sets of descriptors, instructs the GPU to begin processing work using the loaded sets of descriptors defined by one or more descriptor tables, each referencing a portion of the descriptor heap, and, after the GPU is instructed to process the work, the application generates additional sets of descriptors that are loaded into other portions of the descriptor heap, and then instructs the GPU to process work using sets of descriptors defined by one or more other descriptor tables referencing the other portions of the descriptor heap.

4. The computer system of claim 1, wherein the application loads sets of descriptors in a descriptor heap, instructs the GPU to perform work using descriptors in the descriptor heap as referenced by a large descriptor table covering the descriptor heap, wherein the shaders executing on the GPU then dynamically select any resource(s) using the descriptor table.

5. The computer system of claim 1, further comprising a mechanism for the application to define and pass to the GPU pipelined constants.

6. The computer system of claim 1, wherein an application,
for a first collection of resources, configures a descriptor heap, loads sets of descriptors, instructs the GPU to begin processing work using the loaded sets of descriptors defined by one or more descriptor tables, each referencing a portion of the descriptor heap, and, after the GPU is instructed to process the work, the application generates additional sets of descriptors that are loaded into other portions of the descriptor heap, and then instructs the GPU to process work using sets of descriptors defined by one or more other descriptor tables referencing the other portions of the descriptor heap; and
for a second collection of resources, loads sets of descriptors in a descriptor heap, instructs the GPU to perform work using descriptors in the descriptor heap as referenced by a large descriptor table covering the descriptor heap, wherein the shaders executing on the GPU then dynamically select any resource of the second collection of resources using the large descriptor table.

7. The computer system of claim 1, wherein the application programming interface defines application programming interface descriptor heaps and descriptor tables accessed by applications, and hardware-specific descriptor heaps and descriptor tables accessible by hardware, and wherein the application programming interface includes a graphics kernel to map between the application programming interface descriptor heaps and the hardware-specific descriptor heaps and to map between the application programming interface descriptor tables and the hardware specific descriptor tables.

8. The computer system of claim 7, wherein the application programming interface identifies and enforces limits of the hardware with respect to descriptor use, thereby allowing applications to target different hardware with different capabilities.

9. The computer system of claim 8, wherein the limits include maximum descriptor heap size.

10. The computer system of claim 8, wherein the limits include maximum descriptor table size.

11. The computer system of claim 8, wherein the limits include maximum number of descriptor tables.

12. The computer system of claim 8, wherein the limits include ability to dynamically index within descriptor tables.

13. The computer system of claim 1, wherein, for each type of resource, descriptors of the type of resource are grouped together in contiguous locations within the descriptor heap.

14. The computer system of claim 13, wherein, for each type of resource, the descriptor table for the type is defined, specifying a range within the descriptor heap.

15. A computer program product for use with a computer having a central processing unit and a graphics processing unit and memory accessible by the graphics processing unit during execution of commands, wherein the central processing unit executes an operating system that manages access, by applications running on the central processing unit, to resources in the computer system including the graphics processing unit and memory, wherein the operating system provides an application programming interface managing execution of commands by the graphics processing unit, the computer program product comprising:
a computer readable storage device having computer program instructions stored thereon, the computer program instructions, when processed by the computer, defining the application programming interface managing execution of commands by the graphics processing unit and through which applications running on the central processing unit specify, through a runtime engine, commands to the graphics processing unit,
wherein the application running on the central processing unit is operative at runtime to specify commands through the application programming interface including commands specifying shaders to be executed by the graphics processing unit and resources to be used by the shaders,
wherein at runtime, the graphics processing unit is operative to execute the shader using the resources specified by the commands from the application, using descriptors stored in the memory to access the resources, wherein the descriptors are stored in the memory in one or more descriptor heaps referenced by one or more descriptor tables, wherein a descriptor table is defined as a range within a descriptor heap,
wherein the commands from the application through the application programming interface specify the resources to be used by the shaders by providing, and wherein the shader receives, an indication of a descriptor table specifying the descriptors for the resources to be accessed.

16. The computer program product of claim 15, wherein:
the application programming interface first receives from applications descriptor heap contents in advance of instructing the graphics processing unit to perform work; and
the application programming interface second receives an instruction from the application including one or more descriptor tables instructing the GPU to perform work using the descriptors referenced by the one or more descriptor tables.

17. The computer program product of claim 15, wherein an application configures a descriptor heap, loads sets of descriptors, instructs the GPU to begin processing work using the loaded sets of descriptors defined by one or more descriptor tables, each referencing a portion of the descriptor heap, and, after the GPU is instructed to process the work, the application generates additional sets of descriptors that are loaded into other portions of the descriptor heap, and then instructs the GPU to process work using sets of descriptors defined by one or more other descriptor tables referencing the other portions of the descriptor heap.

18. The computer program product of claim 15, wherein the application loads sets of descriptors in a descriptor heap, instructs the GPU to perform work using descriptors in the descriptor heap as referenced by a large descriptor table covering the descriptor heap, wherein the shaders executing on the GPU then dynamically select any resource(s) using the descriptor table.

19. The computer program product of claim 15, wherein the driver further comprises a mechanism for the application to define and pass to the GPU pipelined constants.

20. The computer program product of claim 15, wherein an application,
for a first collection of resources, configures a descriptor heap, loads sets of descriptors, instructs the GPU to begin processing work using the loaded sets of descriptors defined by one or more descriptor tables, each referencing a portion of the descriptor heap, and, after the GPU is instructed to process the work, the application generates additional sets of descriptors that are loaded into other portions of the descriptor heap, and then instructs the GPU to process work using sets of descriptors defined by one or more other descriptor tables referencing the other portions of the descriptor heap; and
for a second collection of resources, loads sets of descriptors in a descriptor heap, instructs the GPU to perform work using descriptors in the descriptor heap as referenced by a large descriptor table covering the descriptor heap, wherein the shaders executing on the GPU then dynamically select any resource of the second collection of resources using the large descriptor table.

21. The computer program product of claim 15, wherein the application programming interface defines application programming interface descriptor heaps and descriptor tables accessed by applications, and hardware-specific descriptor heaps and descriptor tables accessible by hardware, and wherein the application programming interface maps between the application programming interface descriptor heaps and the hardware-specific descriptor heaps and maps between the application programming interface descriptor tables and the hardware specific descriptor tables.

22. A computer implemented process for allocating resources for processing in a computer having a central processing unit and a graphics processing unit and memory accessible by the graphics processing unit during execution of commands, wherein the central processing unit executes an operating system that manages access, by applications running on the central processing unit, to resources in the computer system including the graphics processing unit and memory, wherein the operating system provides an application programming interface managing execution of commands through a runtime engine by the graphics processing unit, the process comprising:
an application, running on the central processing unit, specifying commands through the application programming interface, the commands specifying shaders to be executed by the graphics processing unit and resources to be used by the shaders, the resources being accessed using descriptors stored in the memory;
the application storing, at runtime, the descriptors in one or more descriptor heaps referenced by one or more descriptor tables, with a descriptor table being defined as a range within a descriptor heap; and
the graphics processing unit executing, at runtime, the specified shader an indication of a descriptor table specifying the descriptors for resources to be accessed by the shader when the shader is executed by the graphics processing unit.