referring to fig1 and 2 , before describing the present invention , we will describe the basic operation of the multiprocessor computer system in which the preferred embodiment operates . the cpus 102 , 104 and 106 in the system 100 utilize cache memories and have overlapping address spaces . therefore it is possible for several copies of a particular block of memory to concurrently exist in the caches of different processors . maintaining &# 34 ; cache coherence &# 34 ; means that whenever data is written into a specified location in a shared address space by one processor , the caches for the other processors perform a &# 34 ; cache snoop &# 34 ; operation , during which each cache determines whether it also stores the specified same memory location . if so , the snooping cache updates or otherwise flags the updated block in its cache array . numerous prior art articles have discussed various aspects of cache coherence . see for example , c . p . thacker , l . c . stewart , and e . h . satterthwaite , jr ., &# 34 ; firefly : a multiprocessor workstation ,&# 34 ; ieee transactions on computers , vol . 37 , no . 8 , pp . 909 - 920 ( august 1988 ); and , charles p . thacker , &# 34 ; cache strategies for shared - memory multiprocessors ,&# 34 ; new frontiers in computer architecture conference proceedings , citicorp / tti ( march 1986 ), both of which are hereby incorporated by reference . although the exact operation of the shared memory bus 122 is not relevant to the present invention , some background information on its operation is useful for understanding the operation of the preferred embodiment . in the preferred embodiment the memory bus 122 includes a 64 bit binary data bus 142 which is also used to transmit address signals and read / write commands , a shared signal line 144 , a dirty signal line 146 , three clock lines 148 , an arbitration bus 150 , two parity lines 152 and fourteen binary lines 154 for transmitting error correction codes . the arbitration bus 150 is used to arbitrate simultaneous requests to use the bus . the clock lines 148 are used to control the timing of data transmissions over the memory bus 122 , and the parity and error correction code lines 152 and 154 are used to transmit standard parity and error correction code signals . only the use of the data bus 142 and the shared signal line 144 are relevant to the present invention . the 64 binary data / address lines 142 are time multiplexed so that address and command signals are transmitted during a first time period , and data are transmitted over the same lines during later time periods . when a cpu access to its cache results in a miss , the cache transmits a read command and a specified address on the bus 122 . normally , the requested block of data is then transmitted by the main memory 120 onto the memory bus 122 . however , if any of the other caches contain more up - to - date data for the specified address , that cache asserts an enable signal on the dirty line 146 , in which case that cache sends the requested data instead of the main memory . referring to fig3 each cpu has a local bus 200 , including an address bus 202 , a data bus 204 and a control bus 206 . the address bus 202 carries a set of binary address signals . for convenience , the address bits are broken down into four subsets , denoted here as abcd , where &# 34 ; a &# 34 ; denotes the most significant bits , &# 34 ; b &# 34 ; denotes one or more of the next most significant bits , and so on through &# 34 ; d &# 34 ; which denotes the least significant bits . the reason for dividing the bits of each address into four portions will become apparent from the following discussion . direct map caches work as follows . the cache 112 contains a high speed memory array 220 , which includes a set of b1 blocks , and having an access time of about 10 nanoseconds . each block 222 in the array 220 has a set size , which is generally equal to a power of 2 ( i . e ., 2 x , where x is a positive integer ). in the preferred embodiment , each block 222 contains eight &# 34 ; words &# 34 ;, where each word contains four bytes . thus , the basic addressable storage unit is a thirty - two bit word , and three address bits are required to select a specified word in a block 222 . in addition , there is a high speed tag memory 230 which stores one tag 232 for each block 222 . referring to fig4 each block &# 39 ; s tag 232 , contains an address value 234 which , along with the position of block in the array 220 , identifies the location in main memory of the block 222 . furthermore , each tag 232 contains two status flags for each block 222 : a &# 34 ; valid flag &# 34 ; 236 which denotes whether the block 222 contains valid data , and a &# 34 ; shared flag &# 34 ; 238 which denotes whether or not the same block of data may be stored in the cache of any other processor in the system . the operation of the shared flag in cache memories , including cache memories in the prior art , is as follows . when any one cache , such as cache 112 in fig1 fetches a block of data from main memory , if that same block data is also stored in any other cache , such as cache 114 , that other cache asserts an enabled shared signal on the shared line 144 so that the cache doing the fetch will know that another cache also holds that block . as a result , both the caches 112 and 114 will set the shared flag 238 in the tag 232 for the block . clearly , once a shared flag 238 for a particular block is set , the shared block of data may be overwritten in the other cache with another block of data , in which case the block of data will no longer be shared by two caches . however , the shared flag is still set in the one cache which still stores the previously shared block of data . therefore the shared flag 238 denotes that a particular block of data may be shared with another processor . whenever the cache 112 writes new data into a cache block 222 , cache logic circuit 266 inspects the shared flag 238 for that block &# 39 ; s tag . if the shared flag is enabled , the cache logic circuit 266 performs a write - through operation -- which means that after the new data is stored in the block , the cache logic writes the entire block to main memory 120 ( and to any other caches which share the block ) via the shared memory bus 122 . referring to fig5 the address space of the main memory is represented by address bits abcd , where &# 34 ; d &# 34 ; is the set of bits required to specify the address or location of each word in a cache block 222 . bits &# 34 ; bc &# 34 ; act as an index into the arrays 220 and 230 and identify the position of the block 222 in the array 220 which is being accessed . the tag 232 for a particular line stores the &# 34 ; a &# 34 ; address bits of a particular block of memory . thus the main memory location of the data stored in a cache block 232 is identified by &# 34 ; a &# 34 ; ( from the corresponding tag ) and &# 34 ; bc &# 34 ; ( the index value of the block ). in the preferred embodiment , there are thirty - two address bits a31 through a0 , with a31 being equal to &# 34 ; 1 &# 34 ; only for locations stored in frame buffers . the &# 34 ; a &# 34 ; address bits are a31 through a15 , the &# 34 ; b &# 34 ; address bits are a14 - a11 , the &# 34 ; c &# 34 ; address bits are a10 - a3 , and the &# 34 ; d &# 34 ; address bits are a2 - a0 . thus , the cache 112 contains 4096 blocks , each of which stores eight words . each cache block 222 can store data from any one of 2 17 memory locations in the computer system &# 39 ; s address space , as represented by the seventeen bit address value stored in the corresponding tag 232 . note that the frame buffers 124 and 126 are treated logically as part of main memory 120 . thus , we say that a block of data is &# 34 ; written to main memory &# 34 ;, even if the block of data is image data with an address having a31 equal to &# 34 ; 1 &# 34 ; which is stored in a frame buffer . from another viewpoint the frame buffers can be considered simply to be portion of main memory 120 , with main memory having standard access circuitry that stores data in different portions of the address space in different sets of memory circuits . normal operation of the cache 112 is as follows . when the cpu 102 performs a memory access , the address to be accessed is asserted on the address bus 202 , and read / write control signals are asserted on the control bus 206 . during write operations , data is also asserted on the data bus 204 . denoting the asserted address as abcd , as described above , the cache control logic 260 uses the &# 34 ; bc &# 34 ; address bits to index into the tag array 230 . a comparator 262 compares the value of the indexed tag 232 with the &# 34 ; a &# 34 ; address bits on the address bus 202 . while this comparison is being performed , the cache array 220 is accessed using address bits &# 34 ; bcd &# 34 ;. if the comparator 262 determines that the address value 234 stored in tag 232 and the &# 34 ; a &# 34 ; address bits are equal , and that the tag &# 39 ; s valid flag 236 is enabled , then buffer 264 is enabled , allowing the flow of data between the addressed location in the cache array 220 and the data bus 204 . that is , during a read operation the addressed location in the cache is asserted on the bus 204 , and during a write operation the data on the bus 204 is written into the cache at the specified location . if the comparator 262 in the cache 112 does not find a &# 34 ; hit &# 34 ;, the cache logic 266 passes the access request to its shared memory bus interface 280 , which then fetches from main memory the specified datum so as to satisfy the cpu &# 39 ; s request . more specifically , the interface 280 fetches from main memory an entire block of data corresponding address bits &# 34 ; abc &# 34 ; and loads this data into the block 222 of the cache array 220 corresponding to the value of address bits &# 34 ; bc &# 34 ;. this enables the cache 112 to satisfy the cpu &# 39 ; s request . at the same time , the tag entry 232 for the reference block 222 is updated to denote the source of the new data stored in it . logic circuit 266 is a state machine which governs the status of the cache array access circuits 262 and 264 . logic circuit 266 also governs the process of loading new blocks of data into the cache when the cpu references a memory location that is not stored in the cache . the first problem is that data values in a &# 34 ; write back &# 34 ; cache are not written back to the frame buffer until the cache block holding the frame buffer data is needed to hold some other block of data . the solution to this problem is make the cache operate in a &# 34 ; write - through &# 34 ; mode for those cache blocks which hold frame buffer data . see the above description of write - through cache operation . additional information regarding write - through cache operation can be found in c . p . thacker , l . c . stewart , and e . h . satterthwaite , jr ., &# 34 ; firefly : a multiprocessor workstation ,&# 34 ; ieee transactions on computers , vol . 37 , no . 8 , pp . 909 - 920 ( august 1988 ); and , charles p . thacker , &# 34 ; cache strategies for shared - memory multiprocessors ,&# 34 ; new frontiers in computer architecture conference proceedings , citicorp / tti ( march 1986 ), both of which were cited and incorporated by reference above . referring to fig6 the solution to the first problem is to modify a standard frame buffer 124 so that it asserts an enabled shared signal on the shared line 144 of the memory bus . this is done as follows . whenever a memory read or write operation is performed , the comparator 300 checks to see if the specified address corresponds to the portion of the address space that is stored in the frame buffer &# 39 ; s video ram 302 . the comparator is enabled only if the most significant bit , a31 , is equal to &# 34 ; 1 &# 34 ;, and a predefined number of the remaining most significant bits are compared with a predefined address range value . if the specified address is in the frame buffer 124 , an enabled &# 34 ; frame buffer access &# 34 ; signal is asserted on line 306 , which enables access to the video ram 302 . the &# 34 ; frame buffer access &# 34 ; signal on line 306 is logically anded with the read command signal from the memory bus by nand gate 308 , and the resulting shared signal is asserted on the shared signal line 144 . thus , if any cpu reads a block of data from the frame buffer a negative logic shared signal is asserted on the shared line 144 . referring to fig3 the shared signal generated by the modified frame buffer 124 causes the cache logic 266 of the cache which receives the frame buffer data to store an enabled shared flag 238 in the tag for the receiving cache block . as a result , whenever a cpu 102 modifies new frame buffer data values which are stored in its cache , a write - through operation will be performed by the cache logic 266 because the shared flag for the access cache block will be enabled . this solves the first problem because updated frame buffer data is automatically written into the frame buffer , which overcomes the problems associated with using a &# 34 ; write back &# 34 ; cache in conjunction with a direct mapped frame buffer . the second problem is solved by changing the strategy used by the cache control logic 260 to allocate cache blocks . in particular , rather than assigning a block to an address and fetching the new contents from main memory 120 whenever the location referenced by the cpu is not contained in the cache , we do so only if the reference is a read operation , or is a write of less than a full cache block . when the cpu does a write of a full block , the cache does not allocate a block for the referenced address and fetch its contents . instead , it simply writes the block to memory , bypassing the cache . this avoids useless fetches of frame buffer data . full block writes are typically accomplished either by ( 1 ) setting the size of the cache block to one word , or ( 2 ) by using a cpu which contains write buffers capable of accumulating data written to a cache block and issuing the entire block as a single write operation . the first of these two options is employed in the firefly system , discussed in the &# 34 ; firefly &# 34 ; article cited above , and the second of these two options is employed in the preferred embodiment of the present invention . referring to fig7 the cpu 102 includes write buffers 320 which store data being written by the cpu 102 and issue full blocks of data as a single write operation using the control : signals write and fullblock . the cache control logic circuit 266 includes a state machine 322 , and an and gate 324 which logically ands the write and full block signals on the cpu &# 39 ; s control bus 206 . when both write and full block are enabled , the cpu is writing a full block ( i . e ., eight words ) of data . the output of the and gate is sent to the bus interface 280 , which instructs the interface 280 to transmit the data to the specified address . the output of the and gate is inverted by inverter 326 , and the resulting signal is used to disable the cache &# 39 ; s data buffer 264 so that the data from the cpu will not be written into the cache block array 220 . furthermore , the output from the and gate 324 is sent to the cache logic &# 39 ; s state machine 322 , which will cause the state machine to ignore the entire data write operation , except for the signal sent to the bus interface 280 . the third problem is solved by allowing frame buffer data to occupy only a small fraction of the cache 120 . while this area of the cache may become filled with display information , the majority of the cache is not disturbed by accesses made to the frame buffer . this avoids pollution of the cache with frame buffer data and the increased cache miss rate described above . in the preferred embodiment of the present invention , a direct mapped cache is used . the allocation of address bits for this cache is shown in fig5 corresponding to a cache with 4096 blocks that each store eight words of data . referring to fig3 and 5 , to restrict the fraction of the cache into which frame buffer data may be stored , we reserve a region of the address space for frame buffers and interpret these addresses differently when referencing the cache . in the preferred embodiment , we allow frame buffer data to occupy only 1 / 16 of the cache . note that we have reserved half of the address space , indicated by a31 =&# 34 ; 1 &# 34 ;, for frame buffer memory . as shown in fig3 there is an address circuit 340 which modifies the &# 34 ; b &# 34 ; address bits used for addressing the tag and block arrays 230 and 220 . referring to fig8 the address circuit 340 works as follows . whenever the most significant address bit ( msb , also labelled here as a31 ) on the local address bus 202 is equal &# 34 ; 1 &# 34 ; the cpu is referencing data in a frame buffer . the address circuit uses the most significant address bit to selectively enable either of two buffers 342 or 344 . in particular , when msb is equal to &# 34 ; 0 &# 34 ;, which means that the cpu is referencing non - frame buffer data , buffer 342 is enabled , and the &# 34 ; b &# 34 ; address bits are transmitted unchanged by the address circuit 340 . when msb is equal to &# 34 ; 1 &# 34 ; because the cpu is referencing frame buffer data , buffer 344 is enabled , which causes the &# 34 ; b &# 34 ; address bits to be replace with a predefined binary value , such as &# 34 ; 1111 &# 34 ; by the address circuit 340 . the address circuit 340 thus naps all references to frame buffer locations into a predefined portion of the cache as specified by the predefined binary value for the &# 34 ; b &# 34 ; address bits asserted by buffer 344 . as shown in fig3 the tags 332 in the bottom 1 / 16 of the tag array 230 , marked by reference number 330 , are somewhat larger than the other tags . note that section 330 of the tag array 230 will correspond to whatever predefined value for the &# 34 ; b &# 34 ; address bits that is set in the address circuit 340 . the tags 332 in section 330 of the tag array must store address values corresponding to both the &# 34 ; a &# 34 ; and &# 34 ; b &# 34 ; address bits ( see fig5 ), whereas the other tags store only the &# 34 ; a &# 34 ; address bits . the reason for this is that the &# 34 ; b &# 34 ; address bits are needed to determine the exact frame buffer location which is being stored in cache . the extra bits in the tags 332 for the portion of the cache into which the frame buffer is mapped are handled as follows . referring to fig9 the tag data received from the selected tag ( i . e ., the tag corresponding to the &# 34 ; b &# 39 ; c &# 34 ; address bits ) includes two components : tag - a , which includes the valid flag 236 and address bits corresponding to the &# 34 ; a &# 34 ; address bits , and tag - b , which corresponds to the &# 34 ; b &# 34 ; address bits stored only in portion 330 of the tag array . the comparator circuit 262 used in the cache logic of the preferred embodiment includes two comparators 350 and 352 each of which produces two output signals . comparator 350 compares tag - a with the &# 34 ; a &# 34 ; address bits from the address bus 202 . if the two sets of address bits match , and the valid flag is enabled , the comparator 350 outputs an enabled match - a signal , and otherwise outputs an enabled no - match - a signal . comparator 352 is enabled only if the cpu is accessing frame buffer data , as indicated by a31 ( labelled msb in fig9 ) being equal to &# 34 ; 1 &# 34 ;. comparator 352 compares tag - b with the &# 34 ; b &# 34 ; address bits from the address bus 202 . if the two sets of address bits match , and the valid flag is enabled , the comparator 350 outputs an enabled match - b signal , and otherwise outputs an enabled no - match - b signal . and gate 354 combines the two match - a and match - b signals to produce an enabled match signal only if the accessed tag matches the high order address bits on the local address bus 202 . or gate 356 combines the two no - match - a and no - match - b signals to produce an enabled no - match signal if the accessed tag does not match the high order address bits on the local address bus 202 . the combined effect of the address circuit 340 , comparator 262 and the tags 332 which store extra address information is to map all frame buffer data into a small portion of the cache 112 . the selection of a particular fraction of the cache for frame buffer locations is a tradeoff . a large fraction ( e . g ., one - half or one - quarter ) means that if the pattern of references to the frame buffer exhibits the spatial and temporal locality of normal programs , then the cache makes these references more efficient . on the other hand , a large fraction means that an unfavorable frame buffer reference pattern will displace more &# 34 ; normal &# 34 ; data and program text from the cache . in a planned implementation of this invention , the inventors will use 1 / 32 of a 128 kilobyte cache for frame buffer data . while the present invention has been described with reference to a few specific embodiments , the description is illustrative of the invention and is not to be construed as limiting the invention . various modifications may occur to those skilled in the art without departing from the true spirit and scope of the invention as defined by the appended claims . for example , the circuit shown in fig7 for asserting a shared signal when image data is read from a frame buffer could be replaced by a simple circuit in each cache which stores an enabled shared flag whenever a block of frame buffer data is stored in the cache .