Method and apparatus for buffering graphics data in a graphics system

• US 7,196,710 B1
• Filed: 11/28/2000
• Issued: 03/27/2007
• Est. Priority Date: 08/23/2000
• Status: Expired due to Term

• Current Assignee: Nintendo Company Limited
• Original Assignee: Nintendo Company Limited
• Inventors: Moore, Robert, Fouladi, Farhad
• Primary Examiner(s): Chauhan; Ulka
• Assistant Examiner(s): RICHER, JONI
• Application Number:
  US09/726,215
• Time in Patent Office: 2,310 Days
• Field of Search: 345/531, 345/503, 345/505, 345/554, 345/530, 345/553, 345/501, 345/541, 345/536, 345/522, 345/506, 345/559, 345/556, 709/328, 709/200, 711/110, 711/119, 710/52, 710/57, 710/33, 710/53, 712/227, 375/240.28, 382/154, 365/221
• US Class Current: 345/553
• CPC Class Codes: G06F 3/14 Digital output to display device ; Cooperation and interconnection of the display device with other functional units
• CPC Class Codes: G06T 1/60 Memory management

Abstract

A graphics system including a custom graphics and audio processor produces exciting 2D and 3D graphics and surround sound. The system includes a graphics and audio processor including a 3D graphics pipeline and an audio digital signal processor. Techniques for efficiently buffering graphics data between a producer and a consumer within a low-cost graphics systems such as a 3D home video game overcome the problem that a small-sized FIFO buffer in the graphics hardware may not adequately load balance a producer and consumer—causing the producer to stall when the consumer renders bit primitives. One aspect of the invention solves this invention by allocating part of main memory to provide a variable number of variable sized graphics commands buffers. Applications can specify the number of buffers and the size of each. All writes to the graphics FIFO can be routed a buffer in main memory. The producer and consumer independently maintain their own read and write pointers, decoupling the producer from the consumer. The consumer does not write to the buffer, but uses its write pointer to keep track of data valid positions within the buffer. The producer can write a read command to a buffer that directs the consumer to read a string of graphics commands (e.g., display list) stored elsewhere in the memory, and to subsequently return to reading the rest of the buffer. Display lists can be created by simply writing a command that redirects the output of the producer to a display list buffer.

Claims

1. A 3D graphics system including:

a producer that outputs graphics commands, said producer comprising a microprocessor;

a consumer that consumes the graphics commands outputted by the producer, said consumer comprising graphics hardware including a cache/command processor and pipelined graphics components that transform and rasterize polygons for display; and

a shared memory coupled to the producer and to the consumer, the shared memory having plural buffers allocated therein, said plural buffers each receiving and temporarily storing graphics commands outputted by the producer for delivery to the consumer, at least some of said commands comprising polygon vertex commands, wherein the producer and the consumer are capable of accessing each said buffer independently of one another,

wherein said buffers store inline commands calling display lists comprising further graphics commands including polygon vertex commands for execution by said graphics hardware, said display lists being stored elsewhere in said shared memory,

wherein said polygon vertex commands are provided to said pipelined graphics components, said pipelined graphics components generating images based at least in part on said polygon vertex commands.

2. A graphics system as in claim 1 wherein the producer and the consumer have independent read and/or write pointers.

3. The graphics system of claim 2 wherein the consumer selectively increments the consumer write pointer in response to the producer writing to the active buffer.

4. The graphics system of claim 3 wherein the consumer increments the consumer read pointer as the consumer reads from an active buffer, and suspends reading from the active buffer when the incremented consumer read pointer has a predetermined relationship with the consumer write pointer.

5. A graphics system as in claim 1 wherein the shared memory stores plural variable sized buffers disposed at selected locations within the shared memory.

6. A graphics system as in claim 1 wherein the shared memory stores plural buffers each of which can be independently accessed by the producer and/or the consumer.

7. The graphics system of claim 6 wherein the consumer is incapable of writing to at least an active one of the plural buffers, but maintains, independently of the producer, a write pointer for at least said active one of the plural buffers.

8. The graphics system of claim 6 wherein the producer provides a producer read pointer and a producer write pointer associated with a first of said plural buffers, and the consumer independently maintains a consumer read pointer and a consumer write pointer associated with said first of said plural buffers.

9. The graphics system of claim 6 wherein a first of the plural buffers includes a read command controlling the consumer to consume the display list which the producer has stored elsewhere within the shared memory, and to resume consuming graphics commands from the first buffer after consuming the display list stored elsewhere.

10. The graphics system of claim 9 wherein the read command specifies a starting address and a length of the display list, the read command controlling the consumer to read the display list of the specified length beginning at the specified starting address.

11. The graphics system of claim 1 wherein at least one of said buffers provides circular first-in-first-out access.

12. The graphics system of claim 1 wherein at least one of said buffers provides first-in-first-out access.

13. The graphics system of claim 1 wherein at least one of the buffers can be selectively attached to both the producer and the consumer simultaneously.

14. The graphics system of claim 1 wherein at least one of the buffers is attached to the producer while a further of said plural buffers is attached to the consumer.

15. The system of claim 1 wherein at least one of the buffers is first attached to the producer, and is subsequently detached from the producer and attached to the consumer.

16. The system of claim 1 wherein at least one of the buffers can be attached to the producer, the consumer, or both.

17. The system of claim 1 wherein only one of said plural buffers is attached to the producer at a time.

18. The system of claim 1 wherein only one of said plural buffers is attached to the consumer at a time.

19. The system of claim 1 wherein each of the buffers has a maximum size of 16 KB.

20. The system of claim 1 wherein the producer sets the size of the buffers.

21. The system of claim 1 wherein at least one of the buffers is dynamically sized to store a frame of graphics commands.

22. The system of claim 1 wherein the producer declares the plural buffers by issuing graphics buffer initialization commands specifying buffer starting address and buffer length.

23. The system of claim 1 wherein at least one of the buffers has a length that is a multiple of 32 bytes and has a minimum size of 64 KB.

24. The graphics system of claim 1 wherein the producer may write a breakpoint into at least one of the buffers, the consumer suspending consumption of graphics commands upon encountering the breakpoint.

25. The system of claim 1 wherein at least one of the buffers has an overflow status indicator indicating when the producer overwrites a location therein.

26. The system of claim 1 further including a hardware status register that indicates the status of at least one of the plural buffers.

27. The system of claim 26 wherein the status register includes the following parameters:

position of a producer write pointer relative to buffer full and buffer empty;

buffer overflow;

whether the producer is currently writing into the at least one buffer; and

whether the consumer is currently reading from the at least one buffer.

28. The system of claim 1 further including a hardware controller coupled to at least one of the plural buffers, the hardware controller providing flow control logic to prevent writes from overrunning reads.

29. The system of claim 1 further including a hardware controller coupled to at least one of the buffers, the hardware controller wrapping read and write pointers from a last location to a first location thereof.

30. The system of claim 1 wherein the producer dynamically allocates said buffers within the shared memory.

31. A 3D graphics system including:

a memory shared between a producer and a consumer;

a storage buffer allocated within said shared memory, said storage buffer receiving and temporarily storing graphics commands;

a producer that writes graphics commands into said buffer, said producer maintaining a producer write pointer and a producer read pointer associated with the buffer, said producer comprising a microprocessor; and

a consumer that consumes the graphics commands stored within the buffer, said consumer comprising graphics hardware including a cache/command processor and pipelined graphics components that transform and rasterize polygons for display, the consumer maintaining a consumer write pointer that is independent of the producer write pointer, and a consumer read pointer that is independent of the producer read pointer,

wherein said buffer stores an inline command calling a display command list stored elsewhere in said shared memory for execution by said consumer, said display command list comprising polygon vertex commands that control said pipelined graphics components to draw polygons for display.

32. The graphics system of claim 31 wherein the consumer increments the consumer read pointer each time the consumer consumes from the buffer, and suspends consumption from the buffer when the consumer read pointer has a predetermined relationship with the consumer write pointer.

33. The graphics system of claim 31 wherein the consumer selectively auto-increments the consumer write pointer in response to the producer writing to the buffer.

34. A graphics system including:

a storage buffer that receives and temporarily stores graphics commands;

a producer that writes graphics commands into said buffer, said producer maintaining a producer write pointer and a producer read pointer associated with the buffer; and

a consumer that consumes the graphics commands stored within the buffer, the consumer maintaining a consumer write pointer that is independent of the producer write pointer, and a consumer read pointer that is independent of the producer read pointer,

wherein the producer sends the consumer a configuration command specifying whether the consumer should auto-increment the consumer write pointer in response to producer writes to the buffer.

35. In a 3D graphics system including a graphics command producer that writes graphics commands into a buffer based on a producer write pointer, said command producer allocating said buffer within a memory shared by said command producer and a graphics command consumer, the graphics command consumer reading graphics commands from the buffer based on a consumer read pointer, said graphics command consumer comprising graphics hardware including a cache/command processor and pipelined graphics components that transform and rasterize polygons for display,

an improvement comprising:

a consumer write pointer independently maintained by the consumer, the consumer write pointer indicating the extent of valid data the producer has written into said buffer, the consumer ceasing to consume graphics commands from the buffer upon the consumer read pointer having a predetermined relationship to the consumer write pointer,

wherein said buffer stores an inline command calling a list of graphics commands stored elsewhere in said shared memory for execution by said consumer, said called list of graphics commands including polygon vertex commands that command said pipelined graphics components to draw polygons for display.

36. In an interactive 3D graphics system including a processor module executing an application, a graphics processor module and at least one memory coupled to the processor module and to the graphics processor module, a method of controlling the flow of graphics commands between the processor module and the graphics processor module comprising:

dynamically establishing, under control of the application, a variable number of FIFO buffers in the memory, the application specifying the size of each of the FIFO buffers;

the application controlling the processor module to write graphics commands into at least a first of the plurality of FIFO buffers; and

the application sending graphics commands to the graphics processor module that control the graphics processor module to read, independently of said processor writes, the graphics command from the first FIFO buffer,

wherein said application stores, into at least one of the FIFO buffers, an inline command calling a list of graphics commands stored elsewhere in said memory for execution by said graphics module, said called list of graphics commands including polygon vertex commands that command said graphics module to draw polygons for display.

37. The graphics system of claim 36 wherein the processor module provides a processor module read pointer and a processor module write pointer associated with a first of said plurality of buffers, and the graphics processor module independently maintains a graphics processor module read pointer and a graphics processor module write pointer associated with said first buffer.

38. The graphics system of claim 36 wherein the graphics processor module increments the graphics processor module read pointer each time the graphics processor module reads from the first buffer, and suspends reading from the first buffer when the graphics processor module read pointer has a predetermined relationship with the graphics processor module write pointer.

39. The graphics system of claim 36 wherein the graphics processor module selectively auto-increments the graphics processor module write pointer in response to the processor module writing to the first buffer.

40. The graphics system of claim 36 wherein the graphics processor module maintains, independently of the processor module, a write pointer for at least an active one of the plurality of buffers.

41. The method of claim 36 further including setting a breakpoint, and at least temporarily suspending the graphics processor module from reading a buffer in response to the graphics processor module encountering the breakpoint.

42. The method of claim 36 wherein the selectively controlling step includes suspending the processor module from writing to the buffer upon detection of an overflow.

43. A 3D graphics system including:

a shared memory that receives and temporarily stores graphics commands;

a producer that writes commands into a buffer within said shared memory, said producer comprising a microprocessor, said commands including a first set of graphics commands and a command referencing a second set of graphics commands stored elsewhere within said shared memory; and

a consumer that consumes the first set of graphics commands stored within the buffer and, in response to encountering the referencing command, consumes the second set of graphics commands referenced thereby and subsequently returns to the buffer to consume additional commands therefrom, said consumer comprising graphics hardware including a cache/command processor and further graphics pipeline components that transform and rasterize polygons for display,

wherein said buffer stores an inline command calling a list of display commands stored elsewhere in said shared memory for execution by said consumer, said called list of graphics commands including polygon vertex commands that command said graphics pipeline components to draw polygons for display.

44. The graphics system of claim 43 wherein the buffer is a circular buffer.

45. The graphics system of claim 43 wherein the consumer is incapable of writing to the buffer, but maintains, independently of the producer, a write pointer for the buffer.

46. A graphics system including:

a storage device that receives and temporarily stores graphics commands;

a producer that writes commands into a buffer within said storage device, said commands including a first set of graphics commands and a command referencing a second set of graphics commands stored elsewhere within said storage device; and

a consumer that consumes the first set of graphics commands stored within the buffer and, in response to encountering the referencing command, consumes the second set of graphics commands referenced thereby and subsequently returns to the buffer to consume additional commands therefrom,

wherein the referencing command specifies a starting address of a display list, the referencing command controlling the consumer to read the display list beginning at the specified starting address.

47. A 3D graphics system including:

a storage device that receives and temporarily stores graphics commands;

a producer that writes commands into a buffer within said storage device, said commands including a first set of graphics commands and a command referencing a second set of graphics commands stored elsewhere within said storage device; and

a consumer that consumes the first set of graphics commands stored within the buffer and, in response to encountering the referencing command, consumes the second set of graphics commands referenced thereby and subsequently returns to the buffer to consume additional commands therefrom,

wherein the referencing command specifies a number of data units the consumer is to consume.

48. In a 3D graphics system, a method for passing graphics commands from a producer of graphics commands, said producer comprising a microprocessor, to a consumer of graphics commands, said consumer comprising graphics hardware including a cache/command processor and further graphics pipeline components that transform and rasterize polygons for display, the method comprising:

creating plural variable sized buffers disposed at variable locations within a memory coupled to the producer and the consumer,

temporarily storing graphics commands produced by the producer in the variable sized buffers;

writing, into at least one said buffers, an inline command calling a list of display commands stored elsewhere in the memory;

consuming the graphics commands from the variable sized buffers with the consumer by accessing the buffers independently of the producer;

executing the list of display commands in response to said inline command within said at least one buffer, said list of display commands including polygon vertex commands specifying vertices of polygons to draw within a graphics image;

after consuming the list of display commands, accessing further graphics command within said buffer having said inline command calling said display list written therein;

generating at least a part of said graphics image based at least in part on the consumed graphics commands and said executed display list; and

outputting the generated part of said graphics image to a display.

49. The method of claim 48 wherein the consumer is incapable of writing to at least an active one of the plural buffers, and the method further includes the consumer maintaining, independently of the producer, a write pointer for at least said active one of the plural buffers.

50. The method of claim 48 further including maintaining, with the producer, a producer read pointer and a producer write pointer associated with a first of said plural buffers, and the independently maintaining, with the consumer, a consumer read pointer and a consumer write pointer associated with said first of said plural buffers.

51. The method of claim 50 further including incrementing, with the consumer, a consumer read pointer as the consumer reads from an active buffer, and suspending reading from the active buffer when the incremented consumer read pointer has a predetermined relationship with the consumer write pointer.

52. The method of claim 51 further including selectively incrementing the consumer write pointer in response to the producer writing to the active buffer.

53. The method of claim 48 wherein a first of the plural buffers includes a read command, and the method further includes:

(a) consuming the display list the producer has stored elsewhere within the memory in response to encountering the read command, and

(b) resuming consumption of graphics commands from the first buffer after consuming the display list stored elsewhere.

54. The method of claim 53 wherein the read command specifies a starting address and a length of the display list, and step (a) includes controlling the consumer to read the display list of the specified length beginning at the specified starting address.

55. The method of claim 48 wherein a first of the plural buffers provides circular first-in-first-out access.

56. The method of claim 48 wherein a first of the plural buffers provides first-in-first-out access.

57. The method of claim 48 further including selectively attaching any of the plural buffers to both the producer and the consumer simultaneously.

58. The method of claim 48 further including attaching a first of the plural buffers to the producer and attaching a second of the plural buffers to the consumer.

59. The method of claim 48 further including attaching a first of the plural buffers to the producer, and subsequently detaching the first buffer from the producer and attaching the first buffer to the consumer.

60. The method of claim 48 further including attaching any of the plural buffers to the producer, the consumer, or both.

61. The method of claim 48 further including attaching only one of the plural buffers to the producer at a time.

62. The method of claim 48 further including attaching only one of the plural buffers to the consumer at a time.

63. A method for producing 3D images including:

maintaining a producer write pointer and a producer read pointer associated with a buffer allocated within a memory shared by the producer and a consumer;

writing graphics commands, including an inline display list call, into the buffer, and updating at least the write pointer in response to the writing;

maintaining, in association with the buffer, a consumer write pointer that is independent of the producer write pointer, and a consumer read pointer that is independent of the producer read pointer;

the consumer consuming the graphics commands stored within the buffer, including accessing a display list comprising polygon vertex graphics commands stored elsewhere within said memory in response to encountering said inline display list call within said buffer, updating at least the read pointer in response to the consuming, and, after executing the display list, accessing and consuming further graphics command disposed sequentially within said buffer after the inline display list call;

producing at least a part of a graphics image at least in part in response to the consuming and executing step; and

outputting the generated part of said graphics image to a display.

64. A method of producing 3D images including:

writing commands into a buffer within a shared memory, said commands including a first set of graphics commands and a command referring to a display list stored elsewhere within said shared memory;

consuming the first set of graphics commands stored within the buffer;

in response to encountering the referring command, executing polygon vertex commands in the display list and subsequently automatically returning to consume additional commands from the buffer;

generating at least a part of an image at least in part in response to the consumed first set of graphics commands and said display list; and

outputting the generated part of said graphics image to a display.

65. A method of supplying 3D graphics commands to a 3D graphics command consumer comprising:

(a) storing a command sequence beginning at a predetermined storage location;

(b) supplying a graphics command stream through a FIFO buffer to the consumer, the stream including at least one command that refers the command consumer to a display list comprising polygon vertex commands stored beginning at the predetermined storage location; and

(c) the graphics command consumer executing said display list polygon vertex commands beginning at the predetermined storage location in response to encountering said at least one command that refers the command consumer to the display list,

wherein the producer returns to access additional portions of said graphics command stream from the FIFO buffer after consuming the command sequence beginning at the predetermined storage location;

wherein the graphics command consumer executes said display list polygon vertex commands to generate at least a part of a graphics image and outputting the generated part of said graphics image to a display.

66. A method of efficiently generating successive graphics images on a display device, comprising:

writing commands into a memory buffer, said commands including at least a first set of graphics commands and at least one calling command that calls a further, prestored list of display commands;

consuming, with a 3D graphics engine, at least some of the first set of graphics commands to generate at least a portion of a first image in a frame buffer memory;

in response to encountering the calling command, reading the stored display commands in the display list with the 3D graphics engine and responsively generating at least a further portion of said first image in said frame buffer memory;

the 3D graphics engine subsequently automatically returning from said called display list to consume additional ones of the first set of graphics commands stored in said memory buffer to generate at least an additional portion of the first graphics display image in the frame buffer memory;

displaying the first graphics display image on the display device;

writing additional commands into the same or different memory buffer, said additional commands including at least a second set of graphics commands and at least one calling command that calls the same further, prestored list of display commands;

consuming, with the 3D graphics engine, at least some of the second set of graphics commands to generate at least a portion of a second image in the same or different frame buffer memory;

in response to encountering the calling command, reading the commands in said prestored display list with the 3D graphics engine and responsively generating at least a further portion of said second image in said same or different frame buffer memory, thereby reusing said further, stored list of display commands to generate said second image;

subsequently automatically returning from said called display list to consume, with the 3D graphics engine, additional ones of the second set of graphics commands stored in said memory buffer to generate at least an additional portion of the second graphics display image in the same or different frame buffer memory; and

displaying the second graphics display image on the display device based on the contents of said same or different frame buffer memory.

67. The method of claim 66 wherein said consuming comprises consuming in a first-in-first-out order, thereby relaxing the degree to which the 3D graphics engine needs to be synchronized to the graphics command producer.

68. The method of claim 66 further including allocating a variable number of variable sized memory buffers for receiving and storing graphics command sets.