Abstract:
A method and apparatus for improving pixel data write operations to a tile-based frame buffer. The present invention includes a byte enable first-in first-out register for storing byte enable data for masking pixel data writes to a tile based frame buffer when the pixel data crosses a tile boundary. Pixel data generated by a graphics processor to the frame buffer may traverse multiple tiles. With each 64-bits of pixel data generated, a corresponding byte of byte enable data is generated as mask data for the frame buffer. The byte enable circuit of the present invention may be implemented as a circular shift register to allow the byte enable data to be shifted, rather than being &#34;popped&#34; after the pixel data has been written to the frame buffer. By shifting data rather than &#34;popping&#34; data, the byte enable circuit is able to retain portions of the byte enable data to enable a correct write of a pixel word which may traverse tile boundaries.

Description:
CROSS-REFERENCE TO RELATED APPLICATION 
     The present application claims priority from Provisional Application Ser. No. 06/000,490 entitled &#34;Byte Enable FIFO Architecture&#34; filed Jun. 23, 1995. 
     BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     The present invention relates to computer graphics systems, and, more specifically to an apparatus and a method to optimize writing of graphics data to a tile-based frame buffer. 
     2. Description of Related Art 
     In a computer system with graphics capabilities, a graphics controller executing graphics applications may output data representing an image to be displayed on a display screen. Such data may be frequently stored in data buffering units known as First-In First-Out (FIFO) buffers by the graphics controller prior to writing the data to a frame buffer which contains all of the graphics data representing an image to be displayed on the display device. 
     The frame buffer defines the screen display and may be frequently updated by rewriting its storage specification in part or completely, either to reflect dynamic aspects of the display or to provide for the display of images generated from a different application program. It is also frequently necessary to mask areas of the frame buffer such that those areas are not overwritten by subsequent graphics operations. 
     In masking the frame buffer, byte enables may be used to control write operations to the frame buffer and also to define data masks for the frame buffer. Each byte of pixel data generated by a graphics controller for a graphics operation has byte enable information associated with it to determine whether a particular pixel data will actually get written to the frame buffer. 
     Many prior art graphics controllers typically include a pixel path which may be several pixels wide to allow processing of several pixels of data during each clock cycle in the graphics controller. Processing several pixels of data during each clock cycle implies that the byte enable output during each clock cycle may also be several bits wide (e.g., if the pixel path is 64 bits wide and the pixel depth is 8 bits, then 8 pixels may be generated on every clock). 
     Such prior art graphics controllers may also include a data First-In First-Out (FIFO) register which may be used to store pixel data generated by the graphics controller until the frame buffer is ready for a write. Having a data FIFO requires the graphics controller to include a byte enable FIFO to store the byte enable information associated with each of the pixel data being written to the frame buffer prior to the data being sent to a display unit. 
     FIG. 1 is a block diagram of a computer system having a graphics system utilizing a frame buffer of the prior art. The graphics system includes a graphics processor 120. Computer system 100 includes a central processing unit (CPU) 110 for processing data and instructions, main memory for storing data and instructions, graphics processor 120, frame buffer 130, and display unit 140. 
     System bus 102 may be any one of a plurality of different types of host or input/output (I/O) buses including the Industry Standard Architecture (ISA), the Peripheral Component Interconnect (PCI), etc. Graphics processor 120 is preferably a 64 bit graphics processor coupled to a 32-bit system bus via a host interface (not shown). 
     Graphics processor 120 may include a display path which receives digital data stored in frame buffer 130 and converts such data into appropriate analog outputs required by display unit 140. Graphics processor 120 also controls write operations of graphics data to frame buffer 130. 
     Commands received from CPU 110 may specify operations such as a move display block operation which may indicate to graphics processor 120 to move a block of display data from one area (hereinafter referred to as a source block display) of display unit 140 to another area (hereinafter referred to as a destination block display). 
     To display data on the display unit, prior art graphics systems display implementations typically have two modes of operation, scan line oriented and tile oriented modes. In a scan line oriented operation, the graphics controller may generate and store data in sequential order as it will appear line-by-line on the display device. Data representing display images in the frame buffer may be read out from the frame buffer to the display device in serial order bit-by-bit, or line-by-line. In the tile oriented mode, the display device may be divided into a grid of rectangles of equal size and shape known as tiles. Blocks of data representing an image to be displayed are moved into each tile. 
     The prior art system shown in FIG. 1 may utilize a tile based frame buffer for storing graphics data processed by graphics processor 120. Frame buffer 130 may be divided into areas of equal size to allow frame buffer 130 to be accessed in packets based on the tile size. The tile size may vary depending on the physical structure of frame buffer 130. 
     Each packet of data to be written to frame buffer 130 may comprise a number of bytes of result data and associated byte enables. Typically, most write operations to frame buffer 130 may not cross tile boundaries which allows graphics processor 120 to perform a graphics operations to frame buffer 130 without incurring extra clock cycles. 
     However, some graphics operations may encounter problems of having to span a tile boundary (i.e., in the X direction or the Y direction) in frame buffer 130, graphics processor 120 may therefore have to write data to multiple tiles in frame buffer 130 in order to move a block of pixel data from a source area to a destination area. Writing to multiple tiles requires graphics processor 120 to initiate multiple packet requests to multiple tiles of frame buffer 130 to write result data. An example of the problem faced by graphics processor 120, in the prior art, in trying to write graphics data that cross tile boundaries is illustrated in FIG. 1B. 
     If a line of data 190 crosses a tile boundary in the X direction as illustrated in FIG. 1B (i.e., tiles 1 and 2), the line of data 190 crossing the X tile boundary between tiles 1 and 2 may need to be written to memory as two separate packets of data due to the fact that tiles 1 and 2 may be in two physically different areas of frame buffer 130. 
     These two write packets are represented in FIG. 1B as A and B. The first packet request reads the first word containing the first 8 pixels (8 bytes) from the graphics processor 120 and reads the first word containing the nine bits of byte enable data from a byte enable storage location. The pixel data is stored to the frame buffer using the byte enable data as masking information. 
     The second packet request reads the second word containing the ninth pixel from graphics processor 120 and may want to store the data to B without affecting the rest of tile 2. However, since the first packet request has already read the first word containing all nine bits of byte enable data from the byte enable storage location, the second packet request either has no byte enable data, if the first word has been popped from graphics processor 120, or the byte enable data is invalid if the word of byte enable data is reused. This results in corruption of the frame buffer 130. 
     In order to solve the problem with the prior art illustrated in FIG. 1B, a system is needed which guarantees valid byte enable data for every packet request. 
     SUMMARY OF THE INVENTION 
     The principles of the present invention are embodied in a novel graphics processor architecture which provides for the storing of data representing pixel information with associated byte enable information in a tile based frame buffer without overwriting data already written to a particular tile location in the frame buffer when the pixel data is of such length that it traverses multiple tiles in the frame buffer. The present invention enables the pixel data to be written to the frame buffer in one or more packets when the pixel data traverses a tile boundary in the frame buffer without corrupting the frame buffer due to incorrect byte enable data. 
     The graphics processor of the present invention includes byte enable data first-in-first-out storage units for storing byte enable data associated with each word of pixel data written to the frame buffer. The storage units include circuitry which enable the byte enable data to be popped out of or shifted in the storage units in response to write requests by the frame buffer. The byte enable data is used as masking information to determine whether data stored in the frame buffer should be overwritten or not. 
     The byte enable storage units of the present invention also include pop and shift pointers each loadable with pointer information to identify which byte enable data may be driven out, or shifted within the storage units respectively. The pointer information may be updated as new data is written into the storage units or written out of the storage units. A plurality of logic gates are also provided to store load and write enable information to indicate whether new data may be loaded into the storage units or whether previously stored data may be retained in the storage units during a write operation to the frame buffer. 
     The present invention solves the problem of prior art system&#39;s inability to retain byte enable data when pixel data being written to the frame buffer traverses a tile boundary requiring the data to be written in more than one packet. The present invention retains the byte enable data by utilizing the shifting logic to shift the byte enable data in the storage units until the entire information representing the pixel data being written is completed. 
     During a packet request crossing tile boundaries in the frame buffer which may require data to be written in, for example, two packets, each time data is read from the storage units, data in the byte enable units is shifted to the right by one byte after being used for writing the first packet representing a portion of a line. This guarantees that byte enable data will always be valid at the beginning of a subsequent packet request. 
     The byte enable data is subsequently aligned to enable the second packet transaction of the line to be written to the frame buffer. Byte data representing pixel information to be stored in the frame buffer is popped off the byte enable storage unit after the data representing the entire line has been written to the frame buffer. 
     Advantages of the present invention include enabling pixel data representing single or multi-line operations that cross tile boundaries to be written to one or more locations in a tile-based frame buffer without losing any byte enable data associated with the pixel data. The present invention also has the advantage of having multi-line pixel data to be processed to the frame buffer without incurring extra clock cycles experienced in the prior art. 
     The foregoing and other features, aspects and advantages of the present invention will become more apparent from the following detailed description of the present invention when taken in conjunction with the accompanying drawings. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIG. 1 is a simplified block diagram of a computer system comprising a central processor, a graphics processor, a frame buffer, and a display device. 
     FIG. 1B is a simplified diagram of the tile-based frame buffer illustrating the problem associated with writing data spanning a tile boundary in the prior art. 
     FIG. 2 is a simplified block diagram of a computer system comprising a central processor, a graphics processor, and a tile-based frame buffer of the present invention. 
     FIG. 3 is a simplified block diagram illustrating the architecture of the byte enable unit and the pixel data storage unit in the graphics processor of the present invention. 
     FIG. 4 is a simplified block diagram of the internal circuitry of the byte enable FIFO register of the present invention. 
     FIG. 5 is a simplified block diagram illustrating an exemplary circuitry of two byte enable FIFO registers of the present invention joined together. 
     FIG. 6 is a simplified block diagram illustrating the read/write structure of the byte enable FIFO of the present invention. 
     FIG. 7 is a block diagram illustrating the circular shift register configuration of the byte enable FIFO of the present invention. 
     FIG. 8 is a simplified diagram illustrating the series of steps required to accomplish the goals of the present invention. 
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT 
     In the following detailed description of the present invention, numerous specific details are set forth in order to provide a thorough understanding of the present invention. One skilled in the art will readily recognize from the following discussion that alternative embodiments of the structures and methods illustrated herein may be employed without departing from the principles of the invention. In the present invention, the graphics processor may minimize the number of data accesses to a tile-based frame buffer during a write to a display device if such write operation crosses a tile boundary in a frame buffer. 
     FIG. 2 is a block diagram of a computer system having a graphics system utilizing a tile based frame buffer of the present invention. Computer system 100 includes a central processing unit (CPU) 110 for processing data and instructions, graphics processor 120, frame buffer 130, and display unit 140. Computer system 100 also includes system bus 102 for communicating data and instructions to and from the various components of computer system 100 and CPU 110. 
     Graphics processor 120 is preferably a 64 bit graphics processor coupled to a 32-bit system bus via a host interface (not shown). Graphics processor 120 may include a graphics engine 200 for generating graphics data to be displayed in display unit 140, a pixel data storage unit 210 coupled to graphics engine 200 to temporarily store pixel data to be displayed, a byte enable storage unit 220 coupled to graphics engine 200 for storing mask data associated with the pixel data, a display path 230 coupled to graphics engine 200 which receives digital data stored in frame buffer 130 and converts such data into appropriate analog outputs required by display unit 140. Graphics processor 120 also controls write operations of graphics data to frame buffer 130. 
     Graphics engine 200 generates pixel data which is to be stored in frame buffer 130. This pixel data is temporarily stored in pixel data storage unit 210. Concurrently, graphics engine 200 generates mask data associated with each 64 bits or 8 byte word of pixel data via data lines 301 to be temporarily stored in byte enable storage unit 220. The mask data or byte enable data is used to determine whether data already written to frame buffer 130 will be overwritten by new pixel data stored in pixel data storage unit 210. 
     Graphics engine 200 initiates a packet transfer of data to frame buffer 130 when all pixel data to be transferred to frame buffer 130 has been written to pixel data storage unit 210. All data transfers during a packet transfer are 64 bits wide. To perform a packet transfer, 64 bits or 8 bytes of mask (byte enable) data is transferred from byte enable data storage unit 220 via data lines 305 to frame buffer 130. 
     On each successive clock cycle, one 64-bit word of pixel data is transferred from pixel data storage unit 210 to frame buffer 130. If the pixel data to be written to frame buffer 130 crosses one or more tile boundaries, then two or more packet requests are needed since the pixel and mask data are stored in physically distinct locations in frame buffer 130. 
     This implies that a 64-bit word of byte enable data temporarily stored in byte enable data storage unit 220 may contain data for two packet requests. Thus, during a first packet request, 64 bits of byte enable data are transferred from byte enable storage unit 220 on the first clock cycle and one 64 bit word of pixel data is transferred on each successive clock cycle, until the first packet request is complete. As data is read from the pixel data storage unit 210 on each clock cycle, the byte enable data in byte enable data storage unit 220 is shifted by one byte on each clock cycle. The shifting of data in byte enable data storage unit 220 is described in detail in FIG. 8. By shifting byte enable data in the byte enable storage unit 220, the present invention prevents the loss of byte enable data, as encountered in the prior art, after the first packet is completed. 
     During the second packet request, since the byte enable data has been shifted within the byte enable data storage unit 220, the Least Significant Byte will correspond to the next 64 bit word to be read out of the pixel data storage unit 210. This allows 64 bits of data to be transferred on the first clock cycle and one 64 bit word of pixel data to be transferred on each successive clock cycle until the second packet request is complete. 
     FIG. 3 is a simplified block diagram illustrating the architecture of graphics processor 120 including pixel data storage unit (DATA --  FIFO) 210 and byte enable data storage unit (BE --  FIFO) 220. As shown in FIG. 3, both storage units 210 and 220 receive inputs from Graphics engine 200 in graphics processor 120. And the outputs of the storage units couple to a data selection unit i.e., MUX 300. In addition to storing pixel data and byte enable data, pixel data storage unit 210 and byte enable storage unit 220 may also facilitate data transfers to frame buffer 130. BE --  FIFO 220 may allow the pixel path in graphics processor 120 to make maximum use of the data transfer protocol of frame buffer 130 by allowing a maximum amount of data to be transferred during a frame buffer transfer cycle. 
     Graphics engine 200 may include a transparency unit (not shown) which takes as its inputs the background color of the display screen in display unit 140, a bit mask which may be used for system bus access, an equal or not --  equal operand, and actual data which may be eventually stored in frame buffer 130. Graphics engine 200 further includes logic which performs a write or not --  write operation received in the transparency unit to determine which pixel in frame buffer 140 may or may not be overwritten. Graphics engine 200 generates an 8 bit wide write enable mask which is stored in BE --  FIFO 220 and a 64 bit pixel data which is stored in DATA --  FIFO 210. 
     DATA --  FIFO 210 may receive and store 16 entries of 64 bit wide pixel information representing pixel data to be displayed in display unit 140. BE --  FIFO 220 may store 16 entries of information with each entry being 8 bits (1 byte) wide. Each byte of data stored in BE --  FIFO 220 may include write/not --  write information corresponding to each 64 bit entry in pixel data storage unit 210. Each of the 8 bits of data in each entry of BE --  FIFO 220 may control the write/not --  write attribute for a byte of pixel data in DATA --  FIFO 220. 
     In one embodiment of the present invention, 64 bits of pixel data may be processed at a time requiring one byte of write enable data to be generated for each 64-bit word of pixel data in DATA --  FIFO 210. Graphics processor 120 provides pop signals to both DATA --  FIFO 210 and BE --  FIFO 220 to remove pixel data and byte enable information from the storage units as they are used. The outputs of BE --  FIFO 220 and DATA --  FIFO 210 couple to the input of multiple input multiplexor (MUX) 300. 
     MUX 300 logically selects whether pixel data or byte enable data may be driven to frame buffer 130 depending on the masking information contained in the byte enable data stored in BE --  FIFO 220. MUX 300 drives an output signal 315 comprising byte enable and pixel data information to be stored in frame buffer 130. 
     The preferred embodiment of the present invention imposes two restrictions on the transfer of data from MUX 300 to memory. The first restriction requires the collection of words of 64 bit pixel data and bytes of write enable data so as to optimize data transfer to memory. 
     The second restriction requires data transfers to the memory controller (not shown) must be 64 bits (8 bytes) wide. This means that since data stored in DATA --  FIFO 210 is already 64 bits wide, the write enable data stored in BE --  FIFO 220 must also be 64 bits wide. 
     In the preferred embodiment, write enable data and pixel data may be transferred by first transferring all appropriate byte enable data to the memory controller and subsequently transferring all appropriate pixel data from DATA --  FIFO 210. 
     FIG. 4 is a block diagram depicting in detail one embodiment of byte enable data storage unit 220 of the present invention. In the preferred embodiment of the present invention, the architecture of byte enable data storage unit 220 may comprise two independent 64 bit (8 byte) registers. Each of these registers may comprise a group of eight bytes with each byte capable of being independently loaded with new data. 
     Continuing with reference to FIG. 4, an example of a 1 byte slice of one of the BE --  FIFO 220 registers of the present invention is shown. The example illustrated in FIG. 4 comprises an AND gate 400, a multiple input multiplexor (MUX) 410, and a storage unit (BE --  FIFO) 420. 
     AND gate 400 receives as its inputs BE --  PUSH signal 402, and WRITE --  PTR signal 404. AND gate 400 includes logic which may be used to generate an output signal 409 to MUX 410 which will be active if both of the input signals to AND gate 400 are asserted high. BE --  PUSH signal 402 is asserted high to load new data to BE --  FIFO 420. WRITE --  PTR signal 404 selects which byte is to receive the new data. 
     MUX 410 is coupled to the input of BE --  FIFO 420 (i.e., D input) via output signal 421. MUX 410 receives as one of its inputs NEW --  DATA 405 signal from graphics processor 120. NEW --  DATA 405 signal supplies new data to storage unit 420. MUX 410 also receives as an input SHIFT --  DATA 406 signal supplied by graphics processor 120. 
     SHIFT --  DATA 406 signal comprises data from the output port of previous storage units. MUX 410 may further receive as an input STORED --  DATA 407 signal from the Q output of BE --  FIFO 420 representing data already retained in BE --  FIFO 420. BE --  PUSH 402 signal and BE --  SHIFT 401 signal couple to MUX 410 to enable new data to be written to BE --  FIFO 420. 
     BE --  FIFO 420 may be an 8-bit register for storing byte entries associated with pixel data stored in pixel data storage unit 210 shown in FIG. 2. BE --  FIFO 420 may be a flip-flop register with a D input for receiving input signals to BE --  FIFO 420, a clock input (C) for receiving system clock signals to clock input signals received in BE --  FIFO 420, and a Q output to drive output signals out of BE --  FIFO 420. 
     BE --  FIFO 420 receives at its D input an 8 bit output signal of MUX 410 and drives out of its Q output data out signal 421 to frame buffer 130. BE --  FIFO 420 loads byte enable data associated with 64 bits of pixel data stored in pixel data storage unit 210, if the WR --  POINTER signal 404 points to another byte slice, then the data in this byte slice remains unchanged. 
     BE --  FIFO 420 may operate as a loadable storage register. In other words, new data may be loaded into BE --  FIFO 420 or previously loaded data may be retained in BE --  FIFO 420. Load operations in BE --  FIFO 420 may be performed by asserting BE --  PUSH 402 signal. 
     When BE --  PUSH 402 signal is asserted high by graphics processor 120, new data is clocked onto the D input of BE --  FIFO 420 to be stored therein. When BE --  PUSH 420 signal is asserted low, previously loaded data (i.e., Q output of storage unit 420) is fed back around to the D input of BE --  FIFO 420 thereby preserving the present data in BE --  FIFO 420 and retaining the data until requested by frame buffer 130 during a subsequent frame buffer 130 transfer cycle. 
     FIG. 5 is a simplified block diagram depicting one embodiment of two byte slices of the byte enable storage unit 220 of the present invention joined together. The byte slices shown in FIG. 5 comprise two byte enable storage units i.e., BE --  FIFO --  1 520 and BE --  FIFO --  0 550, a plurality of multiple input multiplexors 510 and 540, a plurality of AND gates 500 and 530, a plurality of input signals 501 through 509, and output signals 521 and 522. 
     In the illustrated embodiment, AND gate 500 is coupled to receive as its inputs a BE --  PUSH signal 502 and WRITE --  PTR signal 503. BE --  PUSH signal 502 and WRITE --  PTR 503 are logically ANDed by AND gate 500 to generate an output signal which is coupled to MUX 510 to enable new data to be written to storage unit 520. 
     MUX 510 receives as its inputs NEW --  DATA signal 504, SHIFT --  DATA signal 505, and STORED --  DATA signal 506. MUX 510 generates an output signal to the D input of BE --  FIFO --  1 520 to write new data from storage unit 520 to storage unit 550. BE --  FIFO --  1 520 receives and stores new data generated by graphics processor 120 via MUX 510 at its D input and drives the stored data out its Q input to MUX 540. BE --  FIFO --  1 520 is clocked by SYSCLK signal 506. 
     AND gate 530 receives as its inputs BE --  PUSH signal 507 supplied by graphics processor 120 and WRITE --  PTR signal 508 which is asserted by byte enable unit 220 to write new data to storage unit 550. AND gate 530 supplies an output signal to couple AND gate 530 to MUX 540. 
     MUX 540 receives as its inputs output signal 521 from storage unit 520, NEW --  DATA signal 509 from graphics processor 120, and BE --  SHIFT signal 501. When asserted high, BE --  SHIFT signal 501 enables data stored in storage unit 520 to be shifted into storage unit 550. MUX 540 supplies an output signal which couples MUX 540 to the D input of storage unit 550. 
     BE --  FIFO --  0 550 supplies STORED --  DATA 511 to frame buffer 130. In the illustrated embodiment, BE --  FIFO --  1 520 and BE --  FIFO --  0 550 are wired together via BE --  SHIFT signal 501. Thus, when graphics processor 120 asserts BE --  SHIFT signal 501, BE --  FIFO --  0 550 is enabled to be filled with data previously held in BE --  FIFO --  1 520, thus shifting the data. 
     In the embodiment described in FIG. 5, a simple addressing scheme has being developed to control the loading of data from storage unit 520 to storage unit 550. This addressing scheme is implemented by assigning a pointer that indicates which entry in the storage units may be loaded. 
     When WRITE --  POINTER signals 503 and 508 are asserted in succession, BE --  PUSH signals 502 and 507 are enabled in succession to allow byte writes to storage units 520 and 550 respectively. When one byte of masking data has been written, the pointer is advanced to enable the next byte write. This operation is repeated until all the byte enable data associated with the pixel data in pixel data FIFO 210 has been loaded. 
     FIG. 6 illustrates one embodiment of the byte enable First-In-First-Out structure and loading mechanism of the present invention. The BE --  FIFO 220 structure illustrated in FIG. 6 comprises the two storage units discussed in FIG. 4 (i.e., storage units 600 and 610, MUX 620, and signal lines 601 through 606. The structure of storage units 600 and 610 may comprise 8 bytes of storage locations (e.g., LSB and MSB) to store byte enable data presented by graphic engine 200 to byte enable unit 220. 
     Referring to FIG. 6, storage unit 600 and 610 include locations to store the Least Significant Byte (LSB) through the Most Significant Byte (MSB) of byte enable data presented to byte enable unit 220. Storage units 600 and 610 receive DATA --  IN signal 601 from graphics engine 200. WRITE --  DATA signal 602 coupled with WR --  POINTER signal 603 to determine which byte of storage unit 600 or 610 will be written. 
     The BE --  FIFO structure may also include a read pointer 604 which couples to storage unit 600 and storage unit 610. READ --  DATA signal 605 couples storage unit 600 and 610 to MUX 620. MUX 620 drives requests of byte enable data out to frame buffer 130. 
     FIG. 7 illustrate one embodiment of the byte enable unit of the present invention. The embodiment illustrated in FIG. 7 is an example of byte enable unit 220 configured as a shift register. Referring to FIG. 7 with reference to FIG. 4, byte enable unit 220 may be configured to perform as a shift register. The shift register operation is performed by using BE --  SHIFT signal 401 described in FIG. 4. When BE --  SHIFT 401 is asserted high, the Q output of one byte-wide storage unit is fed directly to the D input of the next byte wide storage unit so that on the positive edge of the system clock the data stored in one byte-wide storage gets shifted to the next byte-wide storage unit. 
     Additionally, the Q output of the least significant byte storage location of storage unit 420 is connected to MUX at the D input of the most significant byte storage location of storage unit 450 thereby creating a 16 byte loadable circular shift register. BE --  SHIFT signal 401 signals for each storage unit are wired together so that when the BE --  SHIFT signal goes high a circular shifting of data take places. 
     FIG. 8 is simplified block diagram illustrating the flow of data in one embodiment of the byte enable storage unit 220 of the present invention. The illustration in FIG. 8 shows the 16 storage locations that comprise the BE --  FIFO 220 which may be loaded with byte enable data during the positive edge of the graphics system&#39;s clock. 
     Continuing with reference to FIG. 8 and FIG. 4, the flow of data through BE --  FIFO 220 is implemented by monitoring the pop signals presented by graphics processor 120 to BE --  FIFO 220 and DATA --  FIFO 210. To initiate the loading of new data into the register locations of BE --  FIFO 220, BE --  FIFO 220 checks the pop signal to determine if the signal has being asserted high or not. If the byte enable pop signal is asserted high (BE --  POP=1) then BE --  FIFO 220 checks the pop pointer (POP --  PTR) and places the FIFO entry contents at which the POP --  PTR in pointing out on the output bus and increments the POP --  PTR to point at the next FIFO entry. If the BE --  POP signal is not 1 then either a PUSH (load operation) or a shift operation or a hold (do nothing) operation is performed. 
     If BE --  POP=0 (indicating a no pop operation), BE --  FIFO 220 checks BE --  SHIFT 401 and BE --  PUSH 402 signals to determine whether new data will be loaded or whether previously stored data will simply be shifted from one register location to another. 
     In circumstances where new data has to be loaded onto BE --  FIFO 125 (i.e. BE --  PUSH=1), BE --  FIFO 220 checks the BE --  FIFO 220 entry pointer to determine which BE --  FIFO 220 entry will be loaded. Once the FIFO entry to be loaded has been determined, BE --  FIFO 220 checks the byte pointers (i.e. LOAD --  ENABLE signal 403) to determine which byte in BE --  FIFO 220 entry will get the new data. If previously stored data is to be shifted from one register location to another (i.e. BE --  SHIFT signal 401=1) then the loading mechanism in BE --  FIFO 220 shifts data in 8 bits (1 byte) quantities from the most significant byte position to the least significant byte position as illustrated in FIG. 8. 
     In one embodiment of the present invention, BE --  FIFO 220 performs a shifting operation on the system clock&#39;s edge with only 1 byte of data being shifted per clock. If it is necessary to shift the data by 3 bytes, then BE --  SHIFT signal 401 would have to remain high for three system clock cycles. 
     Thus, a method and apparatus is presented for transferring pixel data information from a data storage unit to a tile based frame buffer without overwriting data already stored in such tiles. From the above description, it will be apparent that the invention disclosed herein provides a novel and advantageous method and apparatus for executing pixel information in a computer system. The foregoing discussion discloses and describes exemplary methods and embodiments of the present invention. As will be understood by those familiar with the art, the invention may be embodied in other specific forms without departing from its spirit or essential characteristics, and thus, the described embodiment is not restrictive of the scope of the invention. For example, the invention could be used with any microprocessor platform, including Intel&#39;s X86, the Power PC™, DEC Alpha™, etc., and could be used with any instruction set. The following claims are indicative of the scope of the invention. All variations which come within the meaning and range of equivalency of the claims are to be embraced within their scope.