PatentTips - Indexes of graphics processing objects in GPU commands

BACKGROUND

A graphics processing unit (GPU) is a specialized electronic device that is specifically designed to perform operations related to graphics processing. GPUs are often built with a highly parallel structure that provides more efficient processing than typical, general purpose central processing units (CPUs) for a range of complex graphics-related algorithms. For example, the complex algorithms may correspond to representations of three-dimensional computer graphics. A GPU may implement a number of so-called "primitive" graphics operations, such as forming points, lines, and triangles, to create complex, three-dimensional images on a display more quickly than drawing the images directly to the display with a CPU.

SUMMARY

This disclosure describes techniques of loading batch commands into a graphics processing unit (GPU). As described herein, a GPU driver for the GPU identifies one or more graphics processing objects to be used by the GPU in order to render a batch of graphics primitives. The GPU driver may formulate a batch command that includes indexes associated with the identified graphics processing objects. The GPU driver may then issue the batch command to the GPU. The GPU can use the indexes in the batch command to retrieve the graphics processing objects from memory. After retrieving the graphics processing objects from memory, the GPU may use the graphics processing objects to render the batch of graphics primitives.

In one aspect, a method comprises storing graphics processing objects in a memory module. The method further comprises identifying, with a GPU driver after storing the graphics processing objects in the memory module, ones of the graphics processing objects to be used by a GPU to render a batch of graphics primitives. The method also comprises formulating, with the GPU driver, a batch command to render the batch of graphics primitives with the GPU. The batch command includes indexes that indicate locations in the memory module at which the identified graphics processing objects are stored. In addition, the method comprises issuing the batch command to the GPU. The GPU uses indexes included in the batch command to retrieve the identified graphics processing objects from the memory module and uses the graphics processing objects to render the batch of graphics primitives in order to generate displayable graphics information.

In another aspect, a method comprises receiving, with a GPU, a batch command to render a batch of graphics primitives. The method also comprises using indexes included in the batch command to retrieve, with the GPU, ones of the graphics processing objects stored in the memory module. In addition, the method comprises processing, with the GPU after retrieving the graphics processing objects, the batch of graphics primitives using the retrieved graphics processing objects in order to generate displayable graphics information. A GPU driver identifies graphics processing objects to be used by the GPU to render the batch of graphics primitives after the graphics processing objects are stored in the locations in the memory module, and wherein the GPU driver formulates the batch command such that the batch command includes indexes associated with the identified graphics processing objects

In another aspect, a device comprises a memory module that stores graphics processing objects and a central processing unit (CPU) that executes a GPU driver. The CPU that executes a GPU driver identifies, after the graphics processing object are stored in the memory module, ones of the graphics processing objects that are to be used by a GPU to render a batch of graphics primitives, formulates a batch command to render the batch of graphics primitives with the GPU, and issues the batch command to the GPU. The batch command includes indexes that indicate locations in the memory module at which the ones of the identified graphics processing objects are stored. The GPU receives the batch command, uses the indexes in the batch command to retrieve the graphics processing objects from the memory module, and renders the batch of graphics primitives using the retrieved graphics processing objects.

DETAILED DESCRIPTION

FIG. 1 is a block diagram illustrating an exemplary computing device 2. Computing device 2 may comprise a personal computer, a desktop computer, a laptop computer, a workstation, a video game platform or console, a cellular or satellite radiotelephone, a handheld device such as a portable video game device or a personal digital assistant, a personal music player, a server, an intermediate network device, a mainframe computer, or another type of device that outputs graphical information using one or more of the techniques described herein.

As illustrated in the example of FIG. 1, computing device 2 includes a CPU 4, a GPU 6, and a Random Access Memory (RAM) module 8 may communicate using a bus 10. Bus 10 may comprise a third generation bus such as a HyperTransport bus or an InfiniBand bus. Alternatively, bus 10 may comprise a second generation bus such as an Advanced Graphics Port bus, a Peripheral Component Interconnect (PCI) Express bus, or another type of bus or device interconnect. CPU 4 may comprise a general-purpose or a special-purpose microprocessor. For example, CPU 4 may comprise a Core 2 Processor provided by Intel Corporation of Santa Clara, California or another type of microprocessor. GPU 6 comprises a dedicated graphics rendering device. GPU 6 may be integrated into the motherboard of computing device 2, may be present on a graphics card that is installed in a port in the motherboard of computing device 2, or may be otherwise configured to interoperate with computing device 2. RAM module 8 may be a Synchronous Dynamic Random Access Memory module, a Direct Rambus Dynamic Random Access Memory module, a Double Data Rate 2 or 3 Synchronous Random Access Memory module, or another type of random access memory module.

As illustrated in the example of FIG. 1, RAM module 8 may store a set of graphics processing objects 14A through 14N (collectively, "graphics processing objects 14"). In this context, a "graphics processing object" may comprise a data structure that specifies a type of graphics processing information that GPU 6 may use to perform a graphics operation. One example of a graphic processing object is a shader object. A shader object may comprise a set of instructions that, when executed by GPU 6, performs a shading operation that outputs a color for a particular pixel, given the shapes, the light sources, and camera position of a scene. Other example graphics processing objects may include vertex streams, texture sample state objects, texture memory objects, index buffers, programs/linking objects, state register objects, constant buffers, frame buffer objects, or other types of graphics processing objects.

Graphics processing objects 14 that specify different types of graphics processing information may be arranged in RAM module 8 as different ones of arrays 16A through 16N (collectively, "arrays 16"). Ones of graphics processing objects 14 in one of arrays 16 may be arranged in adjacent memory locations in RAM module 8. Each one of arrays 16 may comprise a block of memory that stores graphics processing objects that specify a particular type of graphics processing information. For example, if array 16A includes two graphics processing objects 14A and 14B, the first memory location of graphics processing object 14B may be the memory location in RAM module 8 that immediately follows the last memory location of graphics processing object 14A. In this example, graphics processing objects 14A and 14B may both be texture memory objects (i.e., objects that specify texture memory graphics processing information).

Each of arrays 16 may be associated with an array base address and an object size. Each of the graphics processing objects in an array of graphics processing objects may be associated with an index that specifies a memory location of a graphics processing object relative to an array base address. In this case, a combination of an array base address with the size and index of a graphics processing object may form the memory address of the graphics processing object. Because the ones of graphics processing objects 14 that specify different types of graphics processing information may be stored in different ones of arrays 16 and because each of arrays 16 may start at a different memory location, the indexes of graphics processing objects that specify different types of graphics processing information indicate memory locations of the graphics processing objects relative to different memory locations.

As illustrated in the example of FIG. 1, CPU 4 executes a software application 18 that generates high-level commands to perform graphics operations on graphics data. For example, software application 18 may be a video game application, a videoconferencing application, a user interface applications, a graphics design application, or another type of software application that includes graphics rendering functionality. The high-level commands generated by software application 18 may include geometry information (e.g., information for vertices of graphics primitives in an image) and other information that describes an image. Software application 18 may provide the high-level commands to an Application Programming Interface (API) 20. API 20 specifies a set of high-level graphics processing methods. For example, API 20 may specify the methods of the OpenGL, OpenVG (vector graphics), Graphics Device Interface (GDI), Quartz, QuickDraw, the Direct3D, or other application programming interfaces. When software application 18 provides a high-level command to API 20, API 20 may invoke one or more methods provided by a GPU driver 12. GPU driver 12 may be a software and/or firmware program executed by CPU 4 in kernel mode or part of GPU driver 12 in user mode for the purpose of facilitating interaction between API 20 and GPU 6.

When CPU 4 loads application 18, GPU driver 12 may pre-compile one or more graphics processing objects. For example, GPU driver 12 may pre-compile all shader objects. When GPU driver 12 compiles a graphics processing object, GPU driver 12 may store the graphics processing object in the one of arrays 16 that stores ones of graphics processing objects 14 that specify similar types of graphics processing information.

When API 20 invokes one or more of the methods implemented by GPU driver 12 in order to render a batch of graphics primitives, GPU driver 12 may identify ones of graphics processing objects 14 to be used by GPU 6 in order to render the batch of graphics primitives. For example, GPU driver 12 may identify a first shader object, a vertex stream object, a second shader object, a set of state registers for use in GPU 6, and a texture memory object as graphics processing objects to be used by GPU 6 to render the batch of graphics primitives. In 2D graphics, graphics primitives may include simple 2D shapes such as straight or curved lines, boxes, arbitrary polygons, circles, and other two dimensional shapes. In 3D graphics, graphics primitives may include simple 3D shapes such as cubes, cylinders, spheres, cones, pyramids, torus, freeform surfaces such as Bezier surfaces and non-uniform rational B-spline surfaces, and other simple 3D shapes. Rendering graphics primitives is a process of producing graphics information (e.g., pixels) of an image from these graphics primitives.

In many cases, application 18 or graphics API 20 provide GPU driver 12 with an identifier for a graphics processing object. The identifier may be a handler or an integer number. GPU driver 12 may create a mapping table that corresponds to an array of graphics processing objects. Each entry of the mapping table corresponds to an entry in the array. Furthermore, each entry of the mapping table may include an identifier and a "valid" flag. The "valid" flag is initialized to "invalid" for all empty entries at the beginning. When GPU driver 12 receives a new graphics processing object and an identifier of the new graphics processing object, GPU driver 12 may use the identifier to allocate an index or an entry in the mapping table. If the mapping table includes an entry for the identifier, GPU driver 12 may retrieve the index specified in the entry. If the mapping table does not include an entry for the identifier, GPU driver 12 may identify an unused entry in the mapping table and assign the index to the new object, set the identifier of the entry to the identifier, and change the "valid" flag of the entry to "valid." GPU driver 12 stores a newly compiled graphics processing object into the entry in the array. In another example, GPU driver 12 may look up or assign an index for an identifier using a hashing function or a cache mechanism.

GPU driver 12 may generate some graphics processing objects internally. For example, GPU driver 12 may generate graphics processing objects that specify state registers. When GPU driver 12 generates a graphics processing object internally, GPU driver 12 may assign a sequential number as an identifier to the graphics processing object. Furthermore, GPU driver 12 may generate a key (e.g., an integer result) by applying one or more hashing functions to the content of the graphics processing object before GPU driver 12 compiles the graphics processing object. GPU driver 12 may assign the key as an identifier of the graphics processing object. GPU driver 12 may use any other mechanism to generate an identifier for an object. After GPU driver 12 assigns the identifier to the graphics processing object, GPU driver 12 may look up an index of the mapping table as described in the previous paragraph.

After identifying the graphics processing objects to be used by GPU 6, GPU driver 12 may search through the ones of graphics processing objects 14 stored in RAM module 8 to find ones of graphics processing objects 14 that GPU driver 12 has identified as being needed to render the batch of graphics primitives. If GPU driver 12 is unable to find one of the identified graphics processing objects, GPU driver 12 may compile this one of the identified graphics processing object and store the compiled graphics processing object into one of arrays 16 in RAM module 8. For example, GPU driver 12 may compile a graphics processing object that specifies state register values used in GPU 6 by storing the values of these state registers as a graphics processing object in memory module 8.

After GPU driver 12 finds or compiles the identified ones of graphics processing objects 14, GPU driver 12 may formulate a batch command for the batch of graphics primitives in a master command buffer 22 in RAM module 8. Master command buffer 22 may be a region in memory module 8 that stores a set of batch commands 24A through 24N prior to the issuance of these batch commands to GPU 6. A batch command is a data structure that contains specifies a set of graphics processing objects. The batch command that GPU driver 12 formulates may include indexes, base addresses of the arrays, types of the graphics processing objects, and the sizes of the identified ones of graphics processing objects 14. The type of a graphics processing object may indicate a pipeline element in GPU 6 that is to use the graphics processing object. In addition to the indexes and base addresses of the identified graphics processing objects, GPU driver 12 may formulate the batch command to include graphics processing objects that are very small in size. For example, if the size of a graphics processing object is not significantly larger than the combined size of an index and a base address, GPU driver 12 may formulate the batch command to directly include this graphics processing object. By directly including small graphics processing objects into the batch command, latency of retrieving the graphics processing objects with GPU 6 can be reduced. Aside from these small graphics processing objects, GPU driver 12 does not create any copies of the graphics processing objects in the batch command or master command buffer 22 when formulating the batch command.

If the identified ones of graphics processing objects 14 include more than one graphics processing object in a single one of arrays 16, GPU driver 12 only inserts the base address, graphics processing object type, and each object size of the array of graphics processing objects into a batch command once. For example, GPU driver 12 may identify a first shader object and a second shader object as graphics processing objects needed to render a batch of graphics primitives. If the first shader object and the second shader object are of the same type, the first shader object and the second shader object may be stored in the same one of arrays 16. When GPU driver 12 formulates a batch command that specifies the first shader object and the second shader object, GPU driver 12 may include the base address of this one of arrays 16, an index of the first shader object, and an index of the second shader object in the batch command. For example a current batch of graphics primitives uses five texture objects with cached indexes 2, 8, 15, 6, and 301. GPU driver 12 includes the five indexes and a base address of the array of texture objects in a texture state load instruction (i.e., a batch command) in the master command buffer. Including the indexes and the base address of the array does not require GPU driver 12 to sort the texture objects indicated by indexes 2, 8, 15, 6, and 301 together. Because GPU driver 12 does not sort these states together, there is no need to move or copy the data in these texture objects.

After GPU driver 12 completes a batch command in master command buffer 22, GPU driver 12 may "issue" the batch command to GPU 6. When GPU driver 12 issues the batch command to GPU 6, the batch command is transmitted via bus 10 to GPU 6.

When GPU 6 receives a batch command, GPU 6 may use the base addresses of the arrays and the indexes of the graphics processing objects to retrieve the graphics processing objects from RAM module 8. When GPU 6 retrieves one of graphics processing objects 14 from RAM module 8, GPU 6 may store a copy of the graphics processing object in a hardware cache 26 within GPU 6. If hardware cache 26 contains a copy of one of graphics processing objects 14, GPU 6 may only need to retrieve the copy of the graphics processing object from hardware cache 26 rather than retrieving the original graphics processing object from RAM module 8. After retrieving the graphics processing objects specified in the batch command, GPU 6 may use the graphics processing objects in the batch command to render the batch of graphics primitives in order to produce displayable graphics information.

The techniques described in this disclosure may provide one or more advantages. For example, a computing device that implements these techniques does not typically create a copy of the graphics processing objects in the batch command for each batch of graphics primitives. Rather, the device creates indexes of the graphics processing objects in the batch command. Because the indexes of the graphics processing objects may be significantly smaller than the graphics processing objects themselves, less bandwidth on bus 10 may be required in order to transmit a batch command to GPU 6. Furthermore, because GPU 6 may cache individual graphics processing objects in hardware cache 26, it might not be necessary for one of the graphics processing objects to be transmitted over bus 10 from RAM module 8 to GPU 6. Because the techniques described in this disclosure may result in fewer graphics processing objects being transmitted over bus 10, bus 10 may have more bandwidth available with which to transmit other information. As a result, the overall performance of a device that implements the techniques described in this disclosure may be improved. In another example, time may be saved because hardware cache 26 in GPU 6 does not need to be flushed between batches of graphics primitives. For instance, a first batch may use a shader object. Because the first batch uses the shader object, a copy of the shader object may be stored in hardware cache 26. Subsequently, GPU 6 may render a second batch of graphics primitives. Later, GPU 6 may render a third batch of graphics primitives. The third batch of graphics primitives may use the shader object used by the first batch. Because the shader object may still be in hardware cache 26, it may be unnecessary for GPU 6 to retrieve the shader object from RAM module 8. This may conserve time, power, and bandwidth.

FIG. 2 is a flowchart illustrating an exemplary operation of GPU driver 12 operating in CPU 4. Initially, GPU driver 12 may pre-compile one or more graphics processing objects and store these graphics processing objects in arrays 16 in RAM module 8 (40). Subsequently, API 20 may invoke a method of GPU driver 12 in order to perform a graphics operation (42). When API 20 invokes the method of GPU driver 12, GPU driver 12 may identify a set of graphics processing objects that are needed to perform the graphics operation (44). After identifying the set of graphics processing objects, GPU driver 12 may determine whether a batch command for the graphics operation includes an index for each of the graphics processing objects in the set (46). If the batch command for the graphics operation does not include an index for each of the graphics processing objects in the set ("NO" of 46), GPU driver 12 determines whether RAM module 8 includes a graphics processing object in the set that does not have an index in the batch command (48). If GPU driver 12 determines that RAM module 8 includes a graphics processing object in the set that does not have an index in the batch command ("YES" of 48), GPU driver 12 may add the array base address and the index of the graphics processing object to the batch command (50). GPU driver 12 may not add the array base address to the batch command if the batch command already includes the array base address. After adding the array base address and the index of the graphics processing object to the batch command, GPU driver 12 may loop back and again determine if the batch command includes an index for each of the identified graphics processing objects (46).

If RAM module 8 does not include the graphics processing object ("NO" of 48), GPU driver 12 may compile the graphics processing object (52). After compiling the graphics processing object, GPU driver 12 may store the graphics processing object in RAM module 8 (54). Next, GPU driver 12 may insert the array base address and the index of the graphics processing object into the batch command (50). After adding the array base address and the index of the graphics processing object to the batch command, GPU driver 12 may loop back and again determine if the batch command includes an index for each of the identified graphics processing objects (46).

If the batch command does includes an index for each of the identified graphics processing objects ("YES" of 46), GPU driver 12 may issue the batch command to GPU 6 (56).

FIG. 3 is a block diagram illustrating details of an exemplary GPU 6. In the example of FIG. 3, GPU 6 includes a set of pipeline engines 70A through 70N (collectively "pipeline engines 70"). Each of pipeline engines 70 may perform operations in a graphics processing pipeline. For example, pipeline engine 70A may perform command evaluation operations, pipeline engine 70B may perform per-vertex operations and primitive assembly operations, pipeline engine 70C may process textures, pipeline engine 70D may perform shading operations, and so on. Pipeline engines 70 may be Application-Specific Integrated Circuits (ASICs), Field-Programmable Gate Arrays (FPGAs), microprocessors, or other types of logic devices. Pipeline engines 70 may be designed to perform particular graphics-related functions or may be implemented in such a way that each of pipeline engines 70 may execute an arbitrary set of instructions. For example, if pipeline engines 70 are implemented in such a way that each of pipeline engines 70 may execute an arbitrary set of instructions, pipeline engines 70 may be used to perform complex mathematical operations. In this way, GPU 6 may act as a "general purpose" graphics processing unit.

When a first one of pipeline engines 70 receives a batch command from CPU 4, the first one of the pipeline engines may generate requests to retrieve each of the graphics processing objects specified in the batch command. After the first one of the pipeline engines generates a request to retrieve one of the graphics processing objects, hardware cache 26 in GPU 6 may determine whether hardware cache 26 stores a copy of the one of the graphics processing objects. Hardware cache 26 may be a hardware cache and may have various replacement policies including direct mapping, 2-way associative, fully associative, or other replacement policies. If hardware cache 26 stores a copy of the one of the graphics processing objects, hardware cache 26 may return the copy of the one of the graphics processing objects to the first one of pipeline engines 70. On the other hand, if hardware cache 26 does not store a copy of the one of the graphics processing objects, hardware cache 26 may forward the request to RAM module 8. When RAM module 8 returns the one of the graphics processing objects, hardware cache 26 may store a copy of the one of the graphics processing objects. Hardware cache 26 may then forward the one of the graphics processing objects to the first one of pipeline engines 70. In another example, the first one of pipeline engines 70 may provide the indexes and array base addresses to one or more of pipeline engines 70. These ones of pipeline engines 70 may then use the indexes and array base addresses to retrieve graphics processing objects. For instance, the first one of pipeline engines 70 may load a texture engine graphics processing object into pipeline engine 70B and may provide pipeline engine 70B with indexes and an array base address of one or more texture map graphics processing objects. When pipeline engine 70B executes the texture engine, pipeline engine 70B may retrieve various ones of the texture map graphics processing objects as needed.

When the first one of pipeline engines 70 receives graphics processing objects for a batch command, the first one of pipeline engines 70 may load the graphics processing objects into various ones of pipeline engines 70. For example, the first one of pipeline engines 70 may provide a first shader object to pipeline engine 70B and a second shader object to pipeline engine 70C. In this example, pipeline engine 70B may execute instructions in the first shader object and provide values that result from executing the first shader object to pipeline engine 70C. Pipeline engine 70C may execute instructions in the second shader object using the values provided by pipeline 70B. Pipeline engine 70C may output values that are used by pipeline engine 70D, and so on.

A last one of pipeline engines 70 may output graphics information to a frame buffer 74. For example, the last one of pipeline engines 70 (e.g., pipeline engine 70D) may output pixels to frame buffer 74. The pixels in frame buffer 74 may represent graphics information that may be displayed on a monitor, screen, or other display apparatus.

When GPU 6 finishes processing a batch command, hardware cache 26 may not be flushed or invalidated. Rather, graphics processing objects may remain stored in hardware cache 26 for several batch commands. In this way, if a subsequent batch command specifies a graphics processing object used in a previous batch command, it may be unnecessary for hardware cache 26 to retrieve the graphics processing object from RAM module 8. Hardware cache 26 may be flushed or invalidated when GPU driver 12 instructs GPU 6 to flush or invalidate hardware cache 26. In addition, graphics processing objects in hardware cache 26 may be replaced by new graphics processing objects.

FIG. 4 is a flowchart that illustrates an exemplary operation of GPU 6. Initially, GPU 6 receives a batch command issued by GPU driver 12 to render a batch of graphics primitives (80). After receiving the batch command, GPU 6 may retrieve from RAM module 8 or hardware cache 26 graphics processing objects at memory locations indicated by indexes in the batch command (82). After retrieving the graphics processing objects, GPU 6 may use pipeline elements 70 to render the batch of graphics primitives using the retrieved graphics processing objects (84). When GPU 6 finishes rendering the batch of graphics primitives using the retrieved graphics processing objects, GPU 6 may output a raster image to frame buffer 74 (86).

SRC=http://www.freepatentsonline.com/EP1978483A1.html