Classifications

• • G—PHYSICS
  • G06—COMPUTING; CALCULATING OR COUNTING
  • G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
  • G06T15/00—3D [Three Dimensional] image rendering
  • G06T15/005—General purpose rendering architectures
• • G—PHYSICS
  • G06—COMPUTING; CALCULATING OR COUNTING
  • G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
  • G06T1/00—General purpose image data processing
  • G06T1/60—Memory management

Definitions

• the present invention pertains to the field of computer systems. More particularly, this invention pertains to the field of reducing primitive storage requirements and improving memory bandwidth utilization in a tiled graphics architecture.
• a three dimensional (3D) object to be represented on the display screen is composed of graphics primitives such as triangle lists, triangle strips and triangle fans etc.
• the primitives of a 3D object to be rendered are defined by a host computer in terms of primitive data.
• the host computer may define the three vertices of the triangle in terms of its spatial location in terms of X, Y and Z coordinates, as well as data defining the red, green and blue (R, G and B) color values of each vertex, and texture coordinates.
• Additional primitive data may be used in specific applications.
• Rendering hardware within a graphics controller interpolates the primitive data to compute the display screen pixels that represent each primitive, and the R, G and B color values for each pixel.
• Figure 1 and Figure 2 show an example of sorting graphics primitives into bins, or tiles.
• a microprocessor fetches data for primitives 1 10, 120, and 130 from a primitive storage area.
• the primitive storage area may be implemented as a portion of the main system memory or may be implemented as a local graphics memory directly coupled to the graphics controller.
• the primitives 1 10, 120, and 130 are eventually to be rendered and then displayed on a display screen, represented by block 100.
• the block 100 is divided into four bins for this example.
• a frame of display data is divided into many more bins than the four shown in this example with a typical bin dimension of 128 x 64 pixels. Four bins are used in this example in order to simplify the discussion.
• the processor After fetching data for a graphics primitive, the processor determines which bin or "tile" the primitive intersects. For example, the processor can determine that primitive 1 10 intersects bin 210 as well as bin 220. The processor then writes the data for the three vertices of primitive 1 10 to an area of graphics memory set aside to store primitive data for bin 210 as well as to an area of graphics memory set aside to store primitive data for bin 220. Similarly, the processor writes vertex data for primitive 120 to storage areas for bins 220 and 240 and writes vertex data for primitive 130 to storage areas for bins 210, 230, and 240. Once the primitives have been sorted into bins, the graphics controller fetches primitive data from the graphics memory and renders the primitives one bin at a time.
• Figure 2 demonstrates how the graphics controller divides the primitives 1 10, 120, and 130 into various primitives that fit into bins 210, 220, 230, and 240.
• the various primitives are divided into bins according to how the primitives intersect the bin boundaries. For example, when the primitive data for bin 210 is fetched from graphics memory, the graphics controller divides primitive 1 10 to create primitive 21 1. Primitive 130 is divided to create primitive 212. The graphics controller then proceeds to render primitives 21 1 and 212. The graphics controller then proceeds to process bin 220 by dividing primitives 1 10 and 120 to create primitives 221 and 222 and by rendering the primitives 221 and 222. The graphics controller continues in a similar fashion to process bins 230 and 240.
• Figure 3 is a block diagram of a prior computer system that implements a tiled graphics architecture.
• Figure 3 shows a processor 310, a system memory 330 including a graphics primitive storage area 332. a graphics controller 340, and a display monitor 350.
• Prior tiled graphics architectures such as that implemented by the system of Figure 3 have a disadvantage of using large amounts of memory bandwidth when moving primitive data from device to device. For example, when the processor 310 processes a primitive, the processor 310 reads the vertex data for the primitive from the graphics primitive storage area 332. The processor 310 then determines which bins that the primitive intersects. The processor 310 then must write several copies of the vertex data back out to the graphics primitive storage area 332 where the number of copies to be written depends on how many bins the primitive intersects.
• a typical graphics primitive can be represented by about 100 bytes of vertex data and that a graphics primitive may intersect several bins. This example will assume that a typical primitive intersects 3 bins.
• the processor 310 must write an average of 300 bytes of vertex data to the graphics primitive storage area 332 for each primitive processed. For one frame of a relatively simple display consisting of 2k graphics primitives, the processor 310 must deliver 600k bytes of data per frame. If the frame display rate is 60 frames per second, the processor 310 must deliver data to the graphics primitive storage area 332 at a rate of 360M bytes per second. For a more complicated display consisting of 100k primitives, the bandwidth requirements increase to 1.8G bytes per second.
• Figure 1 is a diagram of a several 3D objects arranged on a display screen in accordance with prior systems.
• Figure 2 is a diagram depicting the several 3D objects of Figure 1 sorted into bins in accordance with prior systems.
• Figure 3 is a block diagram of a prior system including a tiled graphics architecture.
• Figure 4 is a flow diagram of an embodiment of a method for reducing memory bandwidth utilization in a tiled graphics architecture.
• Figure 5 is a flow diagram of an embodiment of a method for reducing memory bandwidth utilization in a tiled graphics architecture where the graphics primitive storage area is located in system memory.
• Figure 6 is a flow diagram of an embodiment of a method for reducing memory bandwidth utilization in a tiled graphics architecture where the graphics primitive storage area is located in a local graphics memory.
• Figure 7 is a block diagram of a system including an embodiment of a graphics controller that includes a vertex cache.
• a microprocessor reads vertex data for a graphics primitive from graphics memory.
• the processor determines which bins the graphics primitive intersects. All vertices of the primitive are written into a vertex buffer for future reference.
• the vertex buffer may reside in either main system memory or local graphics memory.
• the vertex buffer may be implemented as part of the bin storage area or in a separate memory location.
• the processor determines that the graphics primitive intersects a first and a second bin
• the processor writes a pointer to the first and second bin storage areas.
• the pointer indicates the location in memory of the actual vertex data. Thus, only one copy of the vertex data is moved from the processor to the graphics memory. Because the pointer is smaller in size than the vertex data, less data is moved from the processor to the graphics memory and memory bandwidth utilization is improved.
• microprocessor in the above example and in the example embodiments that follow may be substituted for a 3D graphics processor that handles the same primitive processing as performed by the microprocessor.
• an additional embodiment may include a 3D graphics processor that performs hardware transformation and lighting calculations in hardware.
• the graphics memory in the above example and in the example embodiments that follow may be included as part of a main system memory or may by implemented as a local graphics memory directly coupled to a graphics controller.
• the term "pointer" as used herein is meant to include any means of at least partially indicating the location of vertex data, including a memory address and also including an index.
• the pointer may be a physical or virtual memory address indicating the location of the vertex data.
• the pointer may be an index that can be used to calculate the address location of the vertex data.
• an address may be calculated from an index according to the equation "base address + index * vertex data size".
• an address is assumed to be 32 bits wide
• an index is assumed to be 16 bits wide
• vertex data for a triangular graphics primitive is assumed to be approximately 100 bytes long.
• Other embodiments are possible using a wide range of address, index, and data sizes and lengths.
• Figure 4 is a flow diagram of an embodiment of a method for improving memory bandwidth utilization in a tiled graphics architecture.
• a determination is made as to whether a graphics primitive intersects a first and a second bin. If the graphics primitive is found to intersect the first and the second bin, then at block 420 data for a plurality of vertices corresponding to the graphics primitive are written to a first bin storage area located in a memory device.
• the memory device may comprise the main system memory or may comprise a local graphics memory coupled directly to a graphics controller.
• a plurality of pointers are written to a second bin storage area located in the graphics memory. The plurality of pointers indicate the memory locations for the data for the plurality of vertices.
• pointers By writing pointers to the second bin storage area instead of writing the vertex data, less data is moved from the processor to the graphics memory and memory bandwidth utilization is improved.
• the pointers will be fetched by the graphics controller along with any other second bin primitive data.
• the graphics controller will use the pointers to fetch the vertex data from the first bin storage area.
• FIG. 5 is a flow diagram of an embodiment of a method for improving memory bandwidth utilization in a tiled graphics architecture in a computer system where the graphics memory is implemented as an area within main system memory and where the graphics controller includes a vertex cache.
• the vertex cache provides temporary storage for vertex data and allows for an improvement in system memory to graphics controller memory bandwidth utilization by reducing the amount of vertex data moved between the graphics memory located in main system memory and the graphics controller.
• a processor fetches vertex data for a graphics primitive from system memory and at block 510 the processor performs calculations on the vertex data.
• the vertex data for the graphics primitive includes data for three vertices, although other embodiments are possible where the vertex data for the graphics primitive may include data for any number of vertices.
• the calculations described as part of this embodiment are meant to represent a broad range of well-known techniques for manipulating graphics primitive data.
• the processor determines whether the graphics primitive intersects a first bin, and, assuming there is an intersection, the processor writes the vertex data for the graphics primitive to a first bin storage area in system memory.
• the processor determines whether the graphics primitive intersects a second bin. If the graphics primitive is found to intersect the second bin, then at block 525 the processor writes three pointers to a second bin storage area in system memory. The pointers indicate the memory locations of the three vertices that were previously written to system memory.
• the processor determines whether the graphics primitive intersects a third bin. If the graphics primitive is found to intersect the third bin, then at block 535 the processor writes three pointers to a third bin storage area in system memory. The pointers indicate the memory locations of the three vertices that were previously written to system memory.
• the processor determines whether the graphics primitive intersects a fourth bin. If the graphics primitive is found to intersect the fourth bin, then at block 545 the processor writes three pointers to a fourth bin storage area in system memory. The pointers indicate the memory locations of the three vertices that were previously written to system memory.
• a graphics primitive possibly intersecting four bins
• the graphics primitive may possibly intersect two or more bins.
• a bin may have the dimensions of 128 pixels by 64 pixels, although other bin dimensions are possible.
• the bin intersection determination may be performed in a parallel manner instead of the serial approach described above. For example, a bounding box of the primitive may be used to find all bins that the primitive intersects at once.
• blocks 505 through 545 may be repeated until all primitives have been sorted into bins.
• the graphics controller fetches data from the first bin storage area.
• the data fetched from the first bin storage area and the vertex buffer includes the vertex data for the graphics primitive that was previously written to the system memory at block 515.
• the graphics controller stores the fetched vertex data in the vertex cache.
• the vertex cache includes 16 entries which are 4-way interleaved with each entry capable of storing 32 bytes of vertex data. Other embodiments are possible with different numbers of entries and numbers of ways and further with each entry capable of storing different amounts of vertex data.
• the graphics controller fetches the first bin data and stores the vertex data in the vertex cache, the graphics controller renders the first bin primitives at block 560. As part of the rendering process, the graphics controller determines which portion of each graphics primitive included in the first bin data falls within the first bin and renders only that portion of the primitive.
• the graphics controller proceeds to process the second bin.
• the graphics controller fetches data from the second bin storage area at block 565.
• the data fetched from the second bin storage area includes pointers to the vertex data for the graphics primitive, assuming that an intersection with the second bin was found at block 520.
• the graphics controller uses the pointers to access the vertex data that was previously stored in the vertex cache at block 555. Once the graphics processor has accessed the vertex data, the graphics controller renders the second bin primitives at block 575.
• the above embodiment may be generalized to, based on certain heuristics, render the second bin first and followed by the third, first, and fourth bins. This allows overall system performance optimization measures. For example, load balancing can be used to normalize loadings on front-end and back-end processing in the graphics processor.
• Figure 6 is a flow diagram of an embodiment of a method for improving memory bandwidth utilization in a tiled graphics architecture in a computer system where the graphics memory is implemented as a local graphics memory directly coupled to a graphics controller.
• the local graphics memory provides storage for vertex data and allows for an improvement in system memory to graphics controller memory bandwidth utilization by reducing the amount of vertex data moved between the graphics memory located in main system memory and the graphics controller.
• a processor fetches vertex data for a graphics primitive from local graphics memory or, alternatively, from system memory and at block 610 the processor performs calculations on the vertex data.
• the vertex data for the graphics primitive includes data for three vertices, although other embodiments are possible where the vertex data for the graphics primitive may include data for any number of vertices.
• the calculations described as part of this embodiment are meant to represent a broad range of well-known techniques for manipulating graphics primitive data.
• the processor determines whether the graphics primitive intersects a first bin, and, assuming there is an intersection, the processor writes the vertex data for the graphics primitive to a first bin storage area in the local graphics memory.
• the processor determines whether the graphics primitive intersects a second bin. If the graphics primitive is found to intersect the second bin, then at block 625 the processor writes three pointers to a second bin storage area in local graphics memory. The pointers indicate the memory locations of the three vertices that were previously written to local graphics memory.
• the processor determines whether the graphics primitive intersects a third bin. If the graphics primitive is found to intersect the third bin, then at block 635 the processor writes three pointers to a third bin storage area in local graphics memory. The pointers indicate the memory locations of the three vertices that were previously written to local graphics memory.
• the processor determines whether the graphics primitive intersects a fourth bin. If the graphics primitive is found to intersect the fourth bin, then at block 645 the processor writes three pointers to a fourth bin storage area in local graphics memory. The pointers indicate the memory locations of the three vertices that were previously written to local graphics memory.
• a bin may have the dimensions of 128 pixels by 64 pixels, although other bin dimensions are possible.
• the bin intersection determination may be performed in a parallel manner instead of the serial approach described above. For example, a bounding box of the primitive may be used to find all bins that the primitive intersects at once. As indicated by block 647, blocks 605 through 645 may be repeated until all primitives have been sorted into bins.
• the graphics controller fetches data from the first bin storage area.
• the data fetched from the first bin storage area includes the vertex data for the graphics primitive that was previously written to the local graphics memory at block 615.
• the graphics controller renders the first bin primitives at block 660.
• the graphics controller determines which portion of each graphics primitive included in the first bin data falls within the first bin and renders only that portion of the primitive.
• the graphics controller proceeds to process the second bin.
• the graphics controller fetches data from the second bin storage area at block 665.
• the data fetched from the second bin storage area includes pointers to the vertex data for the graphics primitive, assuming that an intersection with the second bin was found at block 620.
• the graphics controller uses the pointers to access the vertex data that was previously stored in the local graphics memory at block 615. Once the graphics processor has accessed the vertex data, the graphics controller renders the second bin primitives at block 675.
• the above method may be generalized to, based on certain heuristics, render second bin first and then followed by the third, first, and fourth bins. This allows overall system performance optimization measures. For example, load balancing can be used to normalize loadings on front-end and back-end processing in the graphics processor.
• Figure 7 is a block diagram of a computer system including a graphics controller 740 that includes a vertex cache 742.
• the computer system of Figure 7 also includes a processor 710 coupled to a system logic device 720 via a processor bus 715.
• the system logic device 720 provides communication between the processor 710 and a system memory 730.
• the system memory 730 includes a graphics primitive storage area 732.
• the graphics primitive storage area 732 may be separated into storage areas for a plurality of bins.
• the system logic device 720 also serves to couple the graphics controller 740 to the processor 710 and the system memory 730.
• the system of Figure 7 also includes a display monitor 750 coupled to the graphics controller 740.
• the system of Figure 7 may be used with embodiments of methods for improving memory bandwidth utilization such as those discussed above in connection with Figures 4 and 5.
• the processor 710 may read vertex data for a graphics primitive from the graphics primitive storage area 732. The processor 710 may then determine which bins the graphics primitive intersects. The processor 710 then writes the vertex data to a first bin storage area within the graphics primitive storage area 732. If the graphics primitive is found to intersect other bins, then the processor 710 writes pointers to other bin storage areas within the graphics primitive storage area 732. The pointers indicate the location within the first bin storage area where the vertex data is stored.
• the pointers in this example include a 16 bit index from which the memory location of the vertex data may be calculated. Other embodiments are possible where the pointers include a 32 bit address identifying the storage locations of the vertex data. Still other embodiments are possible using different length indices and/or addresses.
• the graphics controller 740 desires to process the first bin.
• the graphics controller 740 fetches the first bin data from the graphics primitive storage area 732.
• the graphics controller 740 stores the vertex data for the graphics primitive in the vertex cache 742.
• the graphics controller 740 then renders the first bin. including the portion of the graphics primitive that falls within the first bin.
• a bin has the dimensions of 128 x 64 pixels.
• the vertex cache 742 in this example includes 16 entries that are 4-way set-associative and are capable of storing 32 bytes of vertex data.
• the graphics primitive of this example is represented by three vertices where each vertex is defined by 32 bytes of data. Other embodiments are possible using other bin dimensions and/or other cache arrangements.
• the graphics controller 740 fetches the data for the second bin from the graphics primitive storage area 732.
• the data for the second bin will include pointers to the vertex data for the graphics primitive assuming that the processor 710 previously determined that the graphics primitive intersects the second bin.
• the graphics controller 740 then uses the pointers to access the vertex data stored in the vertex cache 742.
• the vertex cache 742 serves to improve memory bandwidth utilization by eliminating the necessity for the vertex data to be fetched from the graphics primitive storage area 732 when a copy of the vertex data is stored in the vertex cache 742, as is the case in this example.
• the graphics controller 740 can render the second bin. Subsequent bins can be processed in a similar manner until all bins have been rendered.

Landscapes

• Engineering & Computer Science (AREA)
• Physics & Mathematics (AREA)
• General Physics & Mathematics (AREA)
• Theoretical Computer Science (AREA)
• Computer Graphics (AREA)
• Image Generation (AREA)

Applications Claiming Priority (3)

Publications (1)

Family

ID=24156227

Family Applications (1)

Country Status (8)

Families Citing this family (13)

Family Cites Families (3)

• 2001
  • 2001-03-06 WO PCT/US2001/007225 patent/WO2001075804A1/en active IP Right Grant
  • 2001-03-06 CN CN201210080502.0A patent/CN102842145B/zh not_active Expired - Fee Related
  • 2001-03-06 AU AU2001256955A patent/AU2001256955A1/en not_active Abandoned
  • 2001-03-06 EP EP01930417A patent/EP1269418A1/en not_active Withdrawn
  • 2001-03-06 KR KR1020027013055A patent/KR100550240B1/ko active IP Right Grant
  • 2001-03-06 JP JP2001573406A patent/JP2003529860A/ja active Pending
  • 2001-03-06 CN CN018098916A patent/CN1430769B/zh not_active Expired - Fee Related
  • 2001-04-17 TW TW090107594A patent/TWI233573B/zh not_active IP Right Cessation
• 2003
  • 2003-03-07 HK HK03101674.8A patent/HK1049537A1/zh unknown

Non-Patent Citations (1)

Also Published As

Similar Documents

Legal Events