Computer graphics processing and selective visual display system – Computer graphics display memory system – Texture memory
Reexamination Certificate
1998-03-26
2001-07-10
Chauhan, Ulka J. (Department: 2776)
Computer graphics processing and selective visual display system
Computer graphics display memory system
Texture memory
C345S506000
Reexamination Certificate
active
06259460
ABSTRACT:
BACKGROUND OF THE INVENTION
1. Field of the Invention
The present invention is related to computer graphics hardware for which OPENGL (GRAPHICS LIBRARY) software is an interface thereto, and, in particular, to efficiently recirculating texture cache misses in the computer graphics hardware.
2. Description of the Related Art
Interactive graphics display, in general, is explained in
Computer Graphics: Principles and Practices
, Foley, vanDam, Feiner, and Hughes, Addison-Wesley, 1992, and in
Principles of Interactive Computer Graphics
, William M. Newman and Robert F. Sproull, Second Edition, McGraw-Hill Book Company, New York, 1979. Interactive graphics display generally includes a frame buffer storing pixels (or picture elements), a display, and a display controller that transmits the contents of the frame buffer to the display.
The OpenGL graphics system is a software interface to graphics hardware, and is explained in the
OpenGL Programming Guide, The Official Guide to Learning OpenGL, Second Edition, Release
1.1, by the OpenGL Architecture Review Board, Jackie Neider, Tom Davis, Mason Woo, Addison-Wesley Developers Press, Reading, Mass., 1997, in the
OpenGL Programming Guide, The Official Guide to Learning OpenGL, Release
1, by the OpenGL Architecture Review Board, Jackie Neider, Tom Davis, Mason Woo, Addison-Wesley Publishing Company, Reading, Mass., 1993, and in the
OpenGL Reference Manual, The Official Reference Document for OpenGL, Release
1, the OpenGl Architecture Review Board, Addison-Wesley Publishing Company, Reading, Mass., 1993.
A computer model for interpretation of OpenGL commands is a client-server model. An application program being executed by one computer, typically the client computer, issues commands, which are interpreted and processed by another computer, typically the server computer, on which OpenGL is implemented. The client may or may not operate on the same computer as the server. A computer, then, can make calls through an OpenGL software interface to graphics hardware, and the graphics hardware can reside either on the same computer making the calls or on a remote computer.
A tool for describing how data is processed in OpenGL is a processing pipeline. The OpenGL processing pipeline
10
shown in
FIG. 1
receives commands, and may store the commands for future processing in a display list
14
or execute the commands immediately. The OpenGL processing pipeline includes an evaluator
16
, which approximates curve and surface geometry by evaluating polynomial commands of the input values; per-vertex operations and primitive assembly
18
, in which geometric primitives such as points, line segments, and polygons, described by vertices, are processed, such as transforming and lighting the vertices, and clipping the primitives into a viewing volume; rasterization
20
produces a series of frame buffer addresses and associated values, and converts a projected point, line, or polygon, or the pixels of a bitmap or image, to fragments, each corresponding to a pixel in the framebuffer; per-fragment operations
22
performs operations such as conditional updates to the frame buffer
24
based on incoming and previously stored depth values (to effect depth buffering) and blending of incoming pixel colors with stored colors, masking, and other logical operations on pixel values. The final pixel values are then stored in the frame buffer
24
.
Pixel operations
26
processes input data from the commands
12
which is in the form of pixels rather than vertices. The result of the pixel operations
26
is stored in texture memory
28
, for use in rasterization
20
. The resulting fragments are merged into the frame buffer
24
as if the fragments were generated from geometric data.
In addition, if texturing is enabled during rasterization
20
, a texel is generated from texture memory
28
for each fragment and applied to the fragment. A texel is a texture element obtained from texture memory and represents the color of the texture to be applied to a corresponding fragment. Texturing maps a portion of a specified texture image onto each primitive.
Texture mapping is accomplished by using the color (Red (R), Green (G), Blue (B), or Alpha (A)) of the texture image at the location indicated by the fragment's (s, t, and r) coordinates. In the case of a 2-dimensional image (2-D image), s and t coordinates are applicable, and in the case of a 3-dimensional image (3-D image), then s, t, and r coordinates are applicable.
An example of a texture image
29
and the coordinates used to access it is shown in FIG.
2
.
FIG. 2
shows a two-dimensional texture image with n×m dimensions of n=3 and m=2. A one-dimensional texture would comprise a single strip. The values, &agr; and &bgr;, used in blending adjacent texels to obtain a texture value are also shown. As shown in
FIG. 2
, values of s and t coordinates are each in the range of 0.0 to 1.0.
In implementing the OpenGL processing pipeline in the related art, a memory stores textures of images. Some of the textures are read into a texture cache during system initialization, while others are read into the texture cache upon a texture cache miss. Although there are many reasons that a system may experience a texture cache fault, such as during heavy minification of an image, most texture cache faults are data-dependent, and depend upon the s, t, and r coordinates which are calculated in the OpenGL processing pipeline.
If a texture cache fault occurs in the related art, then the OpenGL processing pipeline must be stalled to allow the system to retrieve the required data from the memory, and store it in the texture cache. However, the OpenGL processing pipeline is difficult to stall in that a performance penalty is assessed in completing the OpenGL processing pipeline and displaying an image. In addition, stalling the OpenGL processing pipeline would typically require a gated clock and/or a multiplexer to be placed at the input of every flipflop used in the OpenGL processing pipeline.
A problem in the related art is that texture cache faults occur in retrieving textures from the texture cache for pixels already launched in the OpenGL processing pipeline, requiring that the OpenGL processing pipeline be stalled.
Another problem in the related art is that performance of the OpenGL processing pipeline is reduced when texture cache faults occur.
A further problem in the related art is that the OpenGL processing pipeline must be stalled to allow data to be retrieved from the memory and read into the texture cache when texture cache faults occur.
SUMMARY OF THE INVENTION
The present invention solves the above-mentioned problems of the related art.
An object of the present invention is to recirculate texture cache misses into the OpenGL processing pipeline.
Another object of the present invention is to process texture cache misses without stalling the OpenGL processing pipeline.
A further object of the present invention is to maintain OpenGL processing pipeline performance if a texture cache fault occurs.
The present invention overcomes the problems in the related art and accomplishes the above-mentioned objects.
The present invention recirculates a texture cache request (i.e., a texture cache read request) resulting in a texture cache miss into a predetermined, earlier stage of the OpenGL processing pipeline, without stalling the OpenGL processing pipeline.
The present invention increases the performance of a graphics chip implementing the present invention by enabling the graphics chip to run at a relatively higher clock rate, increasing the performance of the graphics chip, but not stalling the graphics pipeline of approximately 150 stages being executed by the graphics chip. The present invention can be implemented at a low cost and with minimal design complexity.
If texture cache request resulting in a texture cache miss occurs, the present invention processes the next texture cache request without stalling the OpenGL processing pipeline while the data requested by the faulted texture cache reque
Bentz Ole
Gossett Carroll Philip
Goudy Mark
Chauhan Ulka J.
Silicon Graphics Inc.
Staas & Halsey , LLP
LandOfFree
Method for efficient handling of texture cache misses by... does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Method for efficient handling of texture cache misses by..., we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Method for efficient handling of texture cache misses by... will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-2552503