USING ECC/PARITY BITS TO STORE PREDECODE INFORMATION

Abstract: A microprocessor (10) configured to store predecode information that is removed from an instruction cache (16) is disclosed. In one embodiment, the microprocessor (10) comprises a predecode unit (12) and an instruction cache (16). The predecode unit (12) is configured to receive instruction bytes from a level two cache (50) and generate corresponding predecode information. The instruction cache (16) is coupled to the predecode unit (12) and comprises two pluralities of storage locations (62 and 64), one for storing instruction bytes and a second for storing predecode information corresponding to the instruction bytes. The instruction cache (16) is configured to receive and store the instruction bytes and predecode information from the predecode unit (12). The instruction cache (16) is also configured to output at least part of the corresponding predecode information for storage in the level two cache (50) when the instruction bytes and corresponding predecode information are replaced in the instruction cache (16). The predecode information may be stored in storage locations (60) within the level two cache (50) that are configured to store parity and/or error checking and correction information. A method for storing predecode information in a level two cache (50) when it has been overwritten in an instruction cache (16) is also disclosed. A computer system (200) configured to store predecode information in a level two cache (50) is also disclosed.

Description: TITLE: USING ECC/PARITY BITS TO STORE PREDECODE INFORMATION BACKGROUND OF THE INVENTION 1 Technical Field This invention relates to microprocessors and. more particularly, to decoding variable-length instructions within a microprocessor 2 Background Art The number of software applications written for the x86 instruction set is quite large As a result, despite the introduction of newer and more advanced instruction sets, microprocessor designers have continued to design microprocessors capable of executing the x86 instruction set The x86 instruction set is relatively complex and is charactenzed by a plurality of variable-length instructions A geneπc format illustrative of the x86 instruction set is shown m Fig 1 As illustrated in the figure, an x86 instruction consists of from one to five optional prefix bytes 102, followed by an operation code (opcode) field 104. an optional addressing mode (Mod R/M) byte 106, an optional scale-mdex-base (SIB) byte 108, an optional displacement field 110, and an optional immediate data field 112 The opcode field 104 defines the basic operation for a particular instruction The default operation of a particular opcode may be modified by one or more prefix bytes 102 For example, one of prefix bytes 102 may be used to change the address or operand size for an instruction, to override the default segment used in memory addressing, or to instruct the processor to repeat a string operation a number of times The opcode field 104 follows prefix bytes 102, if present, and may be one or two bytes m length The addressing mode (Mod R/M) byte 106 specifies the registers used as well as memory addressing modes The scale-index-base (SIB) byte 108 is used only m 32-bit base-relative addressing using scale and index factors A base field withm SIB byte 108 specifies which register contams the base value for the address calculation, and an mdex field withm SIB byte 108 specifies which register contains the index value A scale field withm SIB byte 108 specifies the power of two by which the index value will be multiplied before being added, along with any displacement, to the base value The next instruction field is a displacement field 110, which is optional and may be from one to four bytes in length Displacement field 110 contams a constant used m address calculations The optional immediate field 112, which may also be from one to four bytes in length, contams a constant used as an instruction operand The shortest x86 instructions are only one byte long and comprise a single opcode byte The 80286 sets a maximum length for an instruction at 10 bytes, while the 80386 and 80486 both allow instruction lengths of up to 15 bytes The complexity of the x86 instruction set poses manv difficulties m implementing high performance x86-compatιble microprocessors In particular, the variable length of x86 instructions makes decodmg instructions difficult Decoding instructions typically involves determining the boundaπes of an instruction and then identifying each field within the instruction, e g , the opcode and operand fields Decoding typically takes place when the instruction is fetched from the instruction cache prior to execution One method for determining the boundaries of instructions involves generatmg and stormg one or more predecode bits for each instruction byte as it is read from main memory and stored into the mstruction cache. The predecode bits provide information about the instruction byte they are associated with For example, an asserted predecode start bit indicates that the associated mstruction byte is the first byte of an instruction. Once a start bit for a particular instruction byte is calculated, it is stored together with the instruction byte in the mstruction cache When a "fetch" is performed, a number of instruction bytes are read from the instruction cache and decoded in preparation for execution Any associated start bits are scanned to generate valid masks for the individual instructions with the fetch. A valid mask is a series of bits in which each bit corresponds to a particular instruction byte. Valid mask bits associated with the first byte of an mstruction, the last byte of the instruction, and all bytes m between the first and last bytes of the mstruction are asserted. All other valid mask bits are not asserted Once the valid mask has been calculated, it may be used to mask off bytes from other instructions. Turning now to Fig 2, an exemplary valid mask is shown. The figure illustrates a portion of a fetch 120 and its associated start bits 122 Assummg a valid mask 126 for mstruction B 128 is to be generated, start bit 122A, and all bits between start bit 122A and start bit 122B are asserted to generate mask 126. Once generated, valid mask 126 may then be used to mask off all bytes within fetch 120 that are not part of mstruction B 128 As the descπption above indicates, predecode information may be particularly useful m reducing decode tunes. By stoπng the predecode information along with the instruction bytes in the mstruction cache, the predecode information need only be calculated once, even if the corresponding instruction is executed a number of tune (e.g., m a loop). Unfortunately, however, when the mstruction is replaced or discarded from the mstruction cache, any associated predecode information is lost. The next time the mstruction is read mto the mstruction cache, predecode information must once agam be generated The time delay caused by waitmg for the predecode information to be calculated may be particularly damagmg to performance when the mstruction is read into the instruction cache as the result of a branch misprediction or a cache miss. In contrast to instructions that are speculatively prefetched before they are needed, fetches resultmg from branch mispredictions or cache misses may cause the microprocessor's decoders and functional units to stall while waitmg to receive the requested instructions In this case, the time required to produce the predecode information may have a significant impact upon the performance of the microprocessor. For these and other reasons, a method and apparatus for reducmg predecode times is desired. In particular, a method and apparatus for decreasmg the time required to generate predecode information for instructions that have previously been discarded from an instruction cache is desired. DISCLOSURE OF INVENTION The problems outlmed above are in large part solved by a microprocessor capable of storing predecode information in a level two cache. In one embodiment, the microprocessor may be configured to store predecode information m a level two cache when either the predecode information or the corresponding instruction bytes are replaced m the mstruction cache In one embodiment, the microprocessor comprises a predecode unit and an instruction cache. The predecode unit is configured to receive instruction bytes from a level two cache and generate corresponding predecode information The instruction cache is coupled to the predecode unit and comprises two pluralities of storage locations- one for storing instruction bytes, and a second for storing predecode information that corresponds to the mstruction bytes The mstruction cache may be configured to receive and store the instruction bytes and predecode information from the predecode unit The instruction cache may also be configured to output at least a portion of the corresponding predecode information when the instruction bytes and corresponding predecode information are replaced in the instruction cache The predecode mformation may be output for storage in a level two cache If the same instruction bytes are needed after they have been replaced in the instruction cache and before they have been replaced in the level two cache, the mstruction bytes and the predecode mformation accompanying the instructions may be retrieved from the level two cache Advantageously the delay of predecoding the instruction bytes may be bypassed in some cases In another embodiment, the predecode mformation may be stored in storage locations withm the level two cache that are configured to store parity and or error checking and correction mformation. By usmg parity and or error checkmg and correction storage locations, modifications to the level two cache configuration may be reduced or eliminated In yet another embodiment, an invalidation constant may be stored in the level two cache for mstruction bytes that do not yet have valid predecode information. The predecode unit may be configured to detect the invalidation constant when readmg instructions bytes from the level two cache and m response calculate new predecode mformation. A method for predecoding variable-length instructions is also contemplated. In one embodiment, the method compπses reading mstruction bytes from a mam system memory and generatmg predecode mformation that corresponds to the mstruction bytes. The mstruction bytes and predecode information are stored in an mstruction cache. At least a portion of the predecode mformation is output to a level two cache for storage when the instruction bytes corresponding to the predecode mformation are overwritten in the mstruction cache Once again, the predecode information may be stored in storage locations withm the level two cache that are configured to store parity and or error checkmg and correction data. A computer system configured to store predecode data is also contemplated. In one embodiment, the computer system may comprise a level two cache and a microprocessor The microprocessor may be coupled to the level two cache and may be configured with a predecode unit and an mstruction cache as descnbed above The predecode unit may be configured to receive mstruction bytes from the level two cache and generate corresponding predecode information The mstruction cache may be coupled to the predecode unit and may be configured to output at least part of its stored predecode mformation for storage m the level two cache when said instruction bytes are replaced The level two cache may be configured to store the predecode mformation from the mstruction cache in storage locations configured to store parity and or error checking and control data BRIEF DESCRIPTION OF DRAWINGS Other objects and advantages of the invention will become apparent upon readmg the following detailed description and upon reference to the accompanying drawings in which Fig 1 is a block diagram of a generic x86 instruction format Fig 2 is a block diagram illustrating one embodiment of a valid mask. Fig 3 is a block diagram of one embodiment of a microprocessor Fig 4 is diagram illustrating details of one embodiment of the interface between the instruction cache of Fig 3 and a level two cache Fig 5 is diagram illustrating details of the relationship between one embodiment of the instruction cache depicted in Fig 4 and one embodiment of the level two cache from Fig 4 Fig 6 is a flowchart depictmg one embodiment of a method for storing predecode information m a level two cache Fig 7 is a diagram showing one embodiment of a computer system utilizing the microprocessor of Fig 3 While the invention is susceptible to various modifications and alternative forms, specific embodiments thereof are shown by way of example in the drawings and will be described in detail herein It should be understood, however, that the drawings and detailed description thereto are not intended to limit the invention to the particular form disclosed, but on the contrary, the intention is to cover all modifications, equivalents and alternatives falling withm the spirit and scope of the present invention as defined by the appended claims MODE(S) FOR CARRYING OUT THE INVENTION Turning now to Fig 3, a block diagram of one embodiment of a microprocessor 10 is shown Microprocessor 10 includes a prefetch/predecode unit 12, a branch prediction unit 14, an instruction cache 16, an mstruction alignment unit 18, a plurality of decode units 20A-20C, a plurality of reservation stations 22A-22C, a plurality of functional units 24A-24C, a load/store unit 26, a data cache 28, a register file 30, a reorder buffer 32, and MROM unit 34 Elements referred to herein with a particular reference number followed by a letter may be collectively referred to by the reference number alone For example, reservation stations 22A-22C may be collectively referred to as reservation stations 22 Prefetch/predecode unit 12 is coupled to receive instructions from a mam memory subsystem (not shown), and is further coupled to instruction cache 16 and branch prediction unit 14 Similarly, branch prediction unit 14 is coupled to instruction cache 16 Branch prediction unit 14 is also coupled to instruction alignment unit 18 and functional units 24A-C Instruction cache 16 is further coupled to MROM unit 34 and instruction alignment unit 18 Instruction alignment unit 18 is in turn coupled to load/store unit 26 and to respective decode units 20A-C Respective decode units 20A-C are coupled to reservation stations 22A-C, which are further coupled to respective functional units 24A-C Additionally, instruction alignment unit 18 and reservation stations 22 are coupled to register file 30 and reorder buffer 32 Functional units 24 are coupled to load/store unit 26, register file 30, and reorder buffer 32 as well Data cache 28 is coupled to load/store unit 26 and to the mam memory subsystem Finally, MROM unit 34 is coupled to mstruction alignment unit 18 Instructions are prefetched from mam memory by prefetch/predecode unit 12 Prefetch/predecode unit 12 predecodes the variable-length instructions to fixed length instructions which are then stored in mstruction cache 16 Instructions may be prefetched and predecoded before they are actually requested by using a prefetch scheme A variety of prefetch schemes may be employed by prefetch/predecode unit 12 Before proceeding with a more detailed description of predecode unit 12 and mstruction cache 16, general aspects regarding the embodiment of exemplary microprocessor 10 shown in the figure will be described Microprocessor 10 may employ branch prediction in order to speculatively fetch instructions subsequent to conditional branch instructions Branch prediction unit 14 is included to perform branch prediction operations In one embodiment, up to two branch target addresses are stored for each 16-byte portion of each cache line m instruction cache 16 Prefetch predecode unit 12 determines initial branch targets when a particular lme is predecoded Subsequent updates to the branch targets corresponding to a cache line may occur due to the execution of instructions withm the cache line Instruction cache 16 provides an indication of the instruction address being fetched to branch prediction unit 14 This allows branch prediction unit 14 to determine which branch target addresses to select when forming a branch prediction Instruction alignment unit 18 and functional units 24 provide update information to branch prediction unit 14 Because branch prediction unit 14 stores two targets per 16-byte portion of the cache lme, predictions for some branch instructions withm the line may not be stored in branch prediction unit 14 Instruction alignment unit 18 may be configured to detect branch instructions which were not predicted by branch prediction unit 14 Functional units 24 execute the branch instructions and determine if the predicted branch direction was mispredicted The branch direction may be "taken", m which subsequent instructions are fetched from the target address of the branch mstruction Conversely, the branch direction may be "not taken", in which subsequent instructions are fetched from memory locations consecutive to the branch mstruction When a mispredicted branch instruction is detected, instructions subsequent to the mispredicted branch are discarded from the various units of microprocessor 10 A variety of suitable branch prediction algorithms may be employed by branch prediction unit 14 Instruction cache 16 is a high speed cache memory provided to store instructions received from prefetch/predecode unit 12 Stored instructions are then fetched from instruction cache 16 and forwarded to instruction alignment unit 18 In one embodiment, mstruction cache 16 may be configured as a set-associative structure Instruction cache 16 may additionally employ a way prediction scheme m order to speed access times For example, instead of accessing tags identifying each lme of instructions and comparing the tags to the fetch address to select a way, instruction cache 16 may predict the way that is accessed In this manner, the way is speculatively selected pnor to accessing the array Using way prediction, the access time of instruction cache 16 may be similar to a direct-mapped cache After the instruction bytes have been read, a tag comparison is performed for verification If the way prediction is incorrect, the correct instruction bytes are fetched and the incorrect instruction bytes (which are further down the processing pipeline) are discarded It is noted that instruction cache 16 may be implemented in fully associative, set associative, or direct mapped configurations MROM unit 34 is a read-only memory that is configured to store sequences of "fast-path instructions " Fast path instructions are instructions that may be decoded and executed by decoders 20A-C and functional units 24A-C In contrast, "MROM instructions" are instructions which are too complex for direct decoding or execution by decoders 20A-C and functional units 24A-C When instruction cache 16 outputs an MROM mstruction, MROM unit 34 responds by outputting a sequence of fast path instructions More specifically, MROM unit 34 parses and translates the MROM instruction mto a subset of defined fast path instructions to effectuate the desired operation MROM unit 34 dispatches the subset of fast path instructions to decode units 20A-C Once instruction bytes are fetched from instruction cache 16, they are conveyed to instruction alignment unit 18 Instruction alignment unit 18 routes the instructions to one of decode unit 20A-C Register operand information is also detected and routed to register file 30 and reorder buffer 32 Additionally, if the instructions require one or more memory operations to be performed, instruction alignment unit 18 dispatches the memory operations to load/store unit 26 Each decoded instruction is dispatched to reservation stations 22 along with operand address information and displacement or immediate data which may be included with the mstruction. Microprocessor 10 supports out-of-order execution, and thus employs reorder buffer 32 to keep track of the oπgmal program sequence for register read and write operations, to implement register renaming, to allow for speculative instruction execution and branch misprediction recovery, and to facilitate precise exceptions. A temporary storage location within reorder buffer 32 is reserved upon decode of an instruction that involves the update of a register The temporary storage location stores the speculative register state that results from the speculative execution of an instruction If a branch prediction is incorrect, the results from the speculatively- executed instructions along the mispredicted path can be invalidated in the reorder buffer 32 before they are written to register file 30 Similarly, if a particular instruction causes an exception, instructions subsequent to the exception-causmg instruction may be discarded In this manner, exceptions are "precise" (I e., instructions subsequent to the exception-causing instruction are not completed prior to the exception). It is noted that a particular instruction is speculatively executed if it is executed prior to instructions which precede the particular instruction m program order Preceding instructions may be a branch instruction or an exception-causmg instruction, in which case the speculative results may be discarded by reorder buffer 32. The decoded instructions and immediate or displacement data provided at the outputs of instruction alignment unit 18 are routed directly to respective reservation stations 22. In one embodiment, each reservation station 22 is capable of holding mstruction information (i.e., decoded instructions as well as operand values, operand tags and/or immediate data) for up to three pendmg instructions awaiting issue to the corresponding functional unit. It is noted that for the embodiment shown in the figure, each reservation station 22 is associated with a dedicated functional unit 24. Accordingly, three dedicated "issue positions" are formed by reservation stations 22 and functional units 24. In other words, issue position 0 is formed by reservation station 22A and functional unit 24A Instructions aligned and dispatched to reservation station 22A are executed by functional unit 24A Similarly, issue position 1 is formed by reservation station 22B and functional unit 24B; and issue position 2 is formed by reservation station 22C and functional unit 24C Upon decode of a particular instruction, if a required operand is a register location, register address mformation is routed to reorder buffer 32 and register file 30 simultaneously. Those of skill in the art will appreciate that the x86 register file includes eight 32-bit real registers (i.e., typically referred to as EAX, EBX, ECX, EDX, EBP, ESI, EDI and ESP). In embodiments of microprocessor 10 which employ the x86 microprocessor architecture, register file 30 compnses storage locations for each of the 32-bit real registers Additional storage locations may be included within register file 30 for use by MROM unit 34 Reorder buffer 32 contains temporary storage locations for results which change the contents of these registers to thereby allow out of order execution A temporary storage location of reorder buffer 32 is reserved for each instruction which, upon decode, is determined to modify the contents of one of the real registers Therefore, at various points during execution of a particular program, reorder buffer 32 may have one or more locations which contain the speculatively executed contents of a given register If following decode of a given mstruction it is determined that reorder buffer 32 has a previous location or locations assigned to a register used as an operand in the given instruction, reorder buffer 32 forwards to the corresponding reservation station either 1) the value in the most recently assigned location, or 2) a tag for the most recently assigned location if the value has not yet been produced by the functional unit that will eventually execute the previous instruction If reorder buffer 32 has a location reserved for a given register, the operand value (or reorder buffer tag) is provided from reorder buffer 32 rather than from register file 30 If there is no location reserved for a required register m reorder buffer 32, the value is taken directly from register file 30 If the operand corresponds to a memory location, the operand value is provided to the reservation station through load/store unit 26 In one particular embodiment, reorder buffer 32 is configured to store and manipulate concurrently decoded instructions as a unit This configuration will be referred to herein as "line-oriented" By manipulating several instructions together, the hardware employed withm reorder buffer 32 may be simplified For example, a hne-oπented reorder buffer included in the present embodiment allocates storage sufficient for instruction information pertaining to three instructions whenever one or more instructions are dispatched by instruction alignment unit 18 By contrast, a variable amount of storage is allocated m conventional reorder buffers, dependent upon the number of mstructions actually dispatched A comparatively larger number of logic gates may be required to allocate the variable amount of storage When each of the concurrently decoded mstructions has executed, the instruction results are stored into register file 30 simultaneously The storage is then free for allocation to another set of concurrently decoded instructions Additionally, the amount of control logic circuitry employed per instruction is reduced because the control logic is amortized over several concurrently decoded mstructions A reorder buffer tag identifying a particular instruction may be divided into two fields a line tag and an offset tag The lme tag identifies the set of concurrently decoded instructions including the particular instruction, and the offset tag identifies which instruction within the set corresponds to the particular instruction It is noted that stonng instruction results into register file 30 and freemg the corresponding storage is referred to as "retiring" the mstructions It is further noted that any reorder buffer configuration may be employed m vanous embodiments of microprocessor 10 As noted earlier, reservation stations 22 store instructions until the instructions are executed by the corresponding functional unit 24 An mstruction is selected for execution if (I) the operands of the instruction have been provided, and (n) the operands have not yet been provided for mstructions which are withm the same reservation station 22A-22C and which are prior to the instruction in program order It is noted that when an mstruction is executed by one of the functional units 24, the result of that instruction is passed directly to any reservation stations 22 that are waiting for that result at the same time the result is passed to update reorder buffer 32 (this technique is commonly referred to as "result forwarding") An mstruction may be selected for execution and passed to a functional unit 24A-24C during the clock cycle that the associated result is forwarded Reservation staπons 22 route the forwarded result to the functional unit 24 in this case In one embodiment, each functional units 24A-C is configured to perform mteger arithmetic operations of addition and subtraction, as well as shifts, rotates, logical operations, and branch operations It is noted that a floating point unit (not shown) may also be employed to accommodate floating point operations The floating point unit may be operated as a coprocessor, receiving instructions from MROM unit 34 and subsequently communicating with reorder buffer 32 to complete the instructions. Additionally, functional units 24 may be configured to perform address generation for load and store memory operations performed by load store unit 26. Each of the functional units 24 also provides information regarding the execution of conditional branch instructions to the branch prediction unit 14 If a branch prediction was incorrect, branch prediction unit 14 flushes instructions subsequent to the mispredicted branch that have entered the instruction processing pipeline, and causes a fetch of the required instructions from instruction cache 16 or mam memory. It is noted that m such situations, results of instructions in the original program sequence which occur after the mispredicted branch instruction are discarded, including those which were speculatively executed and temporarily stored in load/store unit 26 and reorder buffer 32 Results produced by functional units 24 are sent to reorder buffer 32 if a register value is bemg updated, and to load/store unit 26 if the contents of a memory location are changed. If the result is to be stored in a register, reorder buffer 32 stores the result in the location reserved for the value of the register when the instruction was decoded. A plurality of result buses 38 are included for forwarding of results from functional units 24 and load/store unit 26. Result buses 38 convey the result generated, as well as the reorder buffer tag identifying the mstruction being executed Load store unit 26 provides an interface between functional units 24 and data cache 28. In one embodiment, load/store unit 26 is configured with a load/store buffer having eight storage locations for data and address information for pendmg loads or stores When the buffer is full, mstruction alignment unit 18 waits until load store unit 26 has room for the pendmg load or store request information. Load/store unit 26 also performs dependency checkmg for load memory operations against pendmg store memory operations to ensure that data coherency is maintained. A memory operation is a transfer of data between microprocessor 10 and the mam memory subsystem. Memory operations may be the result of an mstruction which utilizes an operand stored m memory, or may be the result of a load/store instruction which causes the data transfer but no other operation. Additionally, load store unit 26 may include a special register storage for special registers such as the segment registers and other registers related to the address translation mechanism defined by the x86 microprocessor architecture. In one embodiment, load/store unit 26 is configured to perform load memory operations speculatively. Store memory operations may be performed in program order, but may be speculatively stored into the predicted way. If the predicted way is incorrect, the data prior to the store memory operation is subsequently restored to the predicted way and the store memory operation is performed to the correct way. In another embodiment, stores may be executed speculatively as well. Speculatively executed stores are placed into a store buffer, along with a copy of the cache lme prior to the update. If the speculatively executed store is later discarded due to branch misprediction or exception, the cache lme may be restored to the value stored in the buffer. It is noted that load/store unit 26 may be configured to perform any amount of speculative execution, including no speculative execution. Data cache 28 is a high speed cache memory provided to temporarily store data being transferred between load store unit 26 and the main memory subsystem. In one embodiment, data cache 28 has a capacity of stonng up to sixteen kilobytes of data in an eight-way set-associative structure. Similar to mstruction cache 16, data cache 28 may employ a way prediction mechanism It is understood that data cache 28 may be implemented in a variety of specific memory configurations, including set-associative and direct-mapped configurations In one particular embodiment of microprocessor 10 employing the x86 microprocessor architecture, instruction cache 16 and data cache 28 are linearly addressed The lmear address is formed from the offset specified by the instruction and the base address specified by the segment portion of the x86 address translation mechanism Linear addresses may optionally be translated to physical addresses for accessing a mam memory The linear to physical translation is specified by the paging portion of the x86 address translation mechanism It is noted that a linear addressed cache stores lmear address tags A set of physical tags (not shown) may be employed for mapping the linear addresses to physical addresses and for detectmg translatton aliases Additionally, the physical tag block may perform linear to physical address translation Prefetch/Predecode Unit and Instruction Cache Configuration As previously noted, many memory devices designed for use as external caches for microprocessors, e g , Intel's 82491/82492 cache SRAMs, may be configured to store parity information In one embodiment, one panty bit may be stored for every eight data bits Assuming even panty is desired, a data byte of 01101011-, would have an asserted parity bit so that the total number of asserted bits is even The panty bit may be generated by the microprocessor and then stored the external cache along with the data byte When the microprocessor reads the data back from the cache, it may count the asserted data and panty bits If the resulting value does not match the selected parity, then a parity error has occurred and the microprocessor may take appropriate action, e g , signal the occurrence of a memory error to the operating system Other memory device configurations may allocate additional bits for error checking and correction (ECC) While high-end systems such as servers typically support panty and ECC, many low and mid-range system designers choose not activate these features because of the relatively low probability of a data error occurnng In these systems, the parity and ECC bits in level two caches may be used for storing predecode information This may advantageously improve performance without requirmg extensive hardware changes at the system level Turning now to Fig 4, a diagram illustrating details of one embodiment of predecode unit 12 and instruction cache 16 is shown In this embodiment, predecode unit 12 is coupled to a cache 50 via bus interface logic 52 Cache 50 comprises a low-latency, high-bandwidth memory that resides either on the same silicon as microprocessor 10, or on separate silicon that is coupled nearby, e g , on a daughtercard or on a motherboard close to microprocessor 10 Cache 50 may comprise static random access memories (SRAMs), synchronous dynamic access memories (SDRAMs), or other types of low latency memories Cache 50 may reside on the same silicon as microprocessor 10 or separate silicon In some embodiments, cache 50 may be referred to as a "level two" cache because it is the second closest cache to the functional units of microprocessor 10, 1 e , behind level one instruction cache 16 and data cache 28 Cache 50 may also be referred to as an "external cache" because it is external to the microprocessor Bus interface logic 52 may comprise multiplexers, buffers, transceivers, drivers, or any other type of bus interface logic that may enable or improve the transmission of data, address, and control signals between microprocessor 10 and cache 50 In some embodiments, no bus interface logic 52 may be necessary between microprocessor 10 and level two cache 50 For example, if microprocessor 10 and level two cache 50 are physically close enough to one another and the drive capability of their output transistors is high enough, then microprocessor 10 and cache 50 may be coupled to each other without bus interface logic 52 Predecode logic 12 is configured to receive instruction addresses to be prefetched from branch prediction unit 14 and convey them to cache 50 via bus 68, bus interface logic 52, and memory bus 56 If level two cache 50 is storing the mstruction bytes corresponding to the requested address, a predetermined number of instruction bytes (e.g , one cache line of 32 bytes) are conveyed to predecode unit 12 via bus 56, bus mterface logic 52 and bus 68. If the requested instruction bytes are not stored withm level two cache 50, cache 50 is configured to retrieve the requested mstruction bytes from the mam memory subsystem Once the requested mstruction bytes are conveyed from the main memory subsystem, they are conveyed to mstruction cache 16 They may also be stored in cache 50 When predecode unit 12 receives the requested mstruction bytes, it generates predecode mformation for each mstruction byte. In the embodiment illustrated m the figure, predecode unit 12 generates one start bit for each mstruction byte. Assuming predecode unit 12 receives 32 bytes (e.g., one cache line) m response to outputtmg a requested address, predecode unit 12 may be configured to generate one start bit for each instruction byte for a total of 32 start bits Once generated, the start bits are conveyed to instruction cache 16, where they are stored together with their associated instruction bytes. Instruction cache 16 may be locally organized mto a plurality of cache line storage locations 64 and a plurality of predecode mformation storage locations 62, wherein one predecode mformation storage location corresponds to each cache lme storage location. The mstruction bytes and predecode bits may also be routed directly to instruction alignment unit 18. Once all cache lme storage locations 62 withm mstruction cache 16 are full, a number of different algorithms may be used to decide which cache line should be replaced upon a cache miss. For example, to reduce the chance of throwing out information that will be needed m the near future, a least-recently used (LRU) replacement scheme that records the order of cache accesses may be used. When the cache lme to be overwritten is selected, the associated predecode information stored in the corresponding predecode storage location 62 is output from mstruction cache 16 to cache 50 by way of predecode unit 12 and bus mterface logic 52. Predecode unit 12 also conveys the address corresponding to the instruction cache mformation being overwritten When cache 50 receives the predecode bits and the corresponding address from prefetch unit 12 and instruction cache 16, cache 50 is configured to store the predecode bits m the parity bit storage locations 60 associated with the corresponding address In some embodiments, the actual instruction bytes to be overwntten in mstruction cache 16 may also be output to cache 50 for storage along with the predecode bits. This configuration might be advantageous in some embodiments of microprocessor 10 for supporting self-modifying code. For example, store addresses may be "snooped" by instruction cache 16 to determine if a store instruction will overwrite mstruction bytes stored with mstruction cache 16. If so, the store instruction may be performed to mstruction cache 16 and data cache 28, thereby modifying the desired instruction bytes In such a configuration, predecode unit 12 may be configured to recalculate predecode information for the mstruction that has been modified and then store the recalculated predecode bits into instruction cache 16 If cache 50 is configured as a write-back cache, the modified instruction bytes may later be written to cache 50 when the cache line storage location storing the modified instruction bytes is overwritten in instruction cache 16 After the predecode information (and instruction bytes, if so configured) are written to cache 50, the cache line storage location and predecode information storage location withm instruction cache 16 may be safely overwritten with new instruction bytes and new predecode mformation When predecode unit 12 receives a prefetch or fetch request for instruction bytes that have been output to cache 50, predecode unit 12 outputs the requested address to cache 50 If cache 50 is still storing the conesponding instruction bytes and predecode information (l e., they have not been replaced), then cache 50 may be configured to convey them to predecode unit 12. Predecode unit 12 may forward the instruction bytes and corresponding predecode mformation to instruction alignment unit 18 and instruction cache 16 Advantageously, in this embodiment, the process of generating new predecode information for the requested instruction bytes may be bypassed. As previously noted, this might be particularly advantageous in some embodiments of microprocessor 10 when a branch mispredict and or cache miss occurs and functional units 24A-C are m danger of stalling. If, on the other hand, cache 50 has replaced the desired instruction bytes with other instruction bytes located at another address, cache 50 may be configured to retneve the requested bytes from main memory and convey them to predecode unit 12 Cache 50 may be configured to assert a particular control signal when transmitting the instruction bytes to predecode unit 12 to indicate that instruction cache 50 does not have valid predecode mformation for the mstruction bytes being transmitted. In another embodiment, a control unit 80 may monitor cache 50 and store an particular invalidation sequence of predecode bits into parity /ECC storage locations 60 that correspond to an instruction storage location 58 that is being replaced with new instruction bytes from mam memory. This effectively "initializes" the predecode information for the new instruction bytes. In this configuration, cache 50 may be configured to output the invalidation sequence of predecode bits when the corresponding mstruction bytes are requested by predecode unit 12. Advantageously, in this configuration cache 50 may be a standard cache that supports paπty/ECC and need not be modified in any way to be aware of whether the predecode bits it is outputtmg are valid or invalid. Instead, predecode unit 12 may be configured to examine the predecode bits it receives from cache 50 If the predecode bits match the predetermined invalidation sequence, prefetch unit 12 may be configured to calculate new predecode mformation. If the predecode bits do not match the predetermmed invalidation sequence, prefetch unit 12 may be configured to forward the predecode bits from level two cache 50 to instruction cache 16 (and alignment unit 16/decode units 20A-C, if necessary) Note that buses 56 and 68 may be of any convenient size, e.g., 16, 32, 64, or 128 bits. The number of bus lmes used may be reduced by multiplexing data, address, and control buses. In some embodiments, predecode unit 12 and level two cache 50 may be configured to generate panty bits for addresses conveyed and received. These parity bits, however, need not be stored and may be discarded after each address is conveyed In yet another embodiment, predecode mformation m addition to start bits may be generated by predecode unit 12 and stored in instruction cache 16. For example, end bits which identify whether their associated instruction byte is the final byte of an mstruction, and opcode bytes which indicate whether their associated instruction byte is an opcode byte, may also be generated by predecode unit 12 and stored m instruction cache 16 Some or all of these predecode bits may be conveyed to cache 50 when the mstruction bytes are replaced in cache 16, depending upon the number of panty and or ECC bits 60 available within cache 50 In some embodiments, decode units 20A-C may be configured to detect when the predecode information provided by predecode unit 12 or read from mstruction cache 16 is incorrect Inaccuracies in the predecode information may occur for differing reasons depending upon the method used to produce the predecode information In the event of inaccurate predecode information, decode units 20A-C may be configured to stall while predecode unit 12 re-generates the predecode information The new predecode information may then be written to instruction cache 16 over the inaccurate predecode information In another embodiment, decode units 20A-C may be configured to simply discard the inaccurate predecode mformation and complete decodmg themselves Turning now to Fig 5, more details of one embodiment of mstruction cache 16 and cache 50 are shown As previously descnbed, instruction cache 16 may be configured with mstruction storage locations 62 and predecode information storage locations 64 Each predecode information storage location corresponds to one instruction storage location For example, the predecode mformation stored in storage location 80 corresponds to the mstruction bytes stored m instruction storage location 82 In the embodiment illustrated in the figure, storage location 80 stores start bits corresponding to each instruction byte stored in location 82 As shown in the figure, cache 50 may store the same instruction bytes as instruction cache 16 For example, when the mstructions from code segment 72 are requested for the first time, they may be read from mam memory into level two cache 50 and instruction cache 16 Note, however, that level two cache 50 will not have predecode data for code segment 72 Thus, the predetermined invalidation constant (m this case, 00000000 ) is stored m location 90 When predecode unit 12 receives the instruction bytes, it will detect the invalidation constant and proceed to calculate predecode mformation for code segment 72 This predecode information is then stored in storage location 80 withm instruction cache 16 The same process will occur the first time the instructions in code segment 78 are requested However, once the instruction bytes for code segment 78 are replaced in mstruction cache 16, the predecode information is wntten back to level two cache 50 and stored in location 94 If code segment 78 is requested again after it has been replaced in instruction cache 16 and before it has been replaced in level two cache 50, both the instruction bytes and the predecode information for code segment 78 may be read from locations 94-96 and stored m instruction cache 16 This state is illustrated in the figure While any predetermined sequence of bits may be used as an invalidation constant, in some embodiments it may advantageous to select a predecode bit sequence that is unlikely to be generated by predecode unit 12 For example, assummg a maximum mstruction length of 16 bytes and a cachelme length of 32-bytes, it is unlikely that predecode unit 12 will receive a cache lme havmg 32 consecutive instruction bytes without at least one starting byte Thus, selecting an invalidation constant compnsing 32 zeros may be advantageous because it may reduce the number of false invalidations A false invalidation may occur when the predecode bits calculated by predecode unit 12 equal the predetermined invalidation constant If this occurs, the origmal predecode bits read from cache 50 will be discarded and new predecode bits may be calculated, even though the origmal predecode bits were correct In one embodiment, the features described above may be implemented solely withm microprocessor 10 For example, the functionality of control unit 80 may be omitted or may be contained withm microprocessor 10 Similarly, bus interface logic 52 may also be omitted or contained withm microprocessor 10 in some embodiments Implementing the functions described entirely withm microprocessor 10 mav advantageously reduce the cost of implementing a computer system that stores predecode information as disclosed In other embodiments, the desired functions may be spread between microprocessor 10 and one or more mterface or support chips Turning now to Fig 6, a flowchart illustrating one embodiment of a method for storing predecode information in level two cache 50 is shown First, instruction bytes are requested from instruction cache 16 (step 140) If the requested bytes are stored withm instruction cache 16, they are conveyed to alignment unit 16 and decode units 20A-C along with their conespondmg predecode mformation (steps 142 and 152) If, on the other hand, the requested instruction bytes are not stored withm mstruction cache 16, the requested address is forwarded to level two cache 50 (steps 142 and 144) If the requested mstruction bytes are not stored in level two cache 50, then they are read from the main memory subsystem (steps 146 and 148) When the requested mstruction bytes are received from the mam memory subsystem, they are stored m level two cache 50 along with an invalidation constant (steps 148 and 150) As previously noted, the invalidation constant effectively initializes the predecode storage location withm level two cache 50, thereby signaling to predecode unit 12 that new predecode information should be generated When predecode unit 12 receives the instruction bytes and the predecode bits, the predecode bits are examined to determine if they equal the invalidation constant (steps 154 and 156) If the predecode bits equal the invalidation constant, predecode unit 12 is configured to generate new predecode information (steps 156 and 164) The mstruction bytes and new predecode information are then stored m mstruction cache 16 (step 158) If stormg the instruction bytes and new predecode mformation entails replacing a previously stored cache lme withm instruction cache 16, the predecode mformation corresponding to the previously stored cache line that is bemg overwntten is stored back to level two cache 50 (steps 160 and 166) Note that the steps m the figure are portrayed in a serial manner for explanatory purposes only Other embodiments are possible and contemplated A number of the steps above may be combined or performed m parallel For example, steps 150 and 154 may be performed m parallel Furthermore, as previously noted, the steps involving the use of an invalidation constant are optional Exemplary Computer System Turning now to Fig 7, a block diagram of one embodiment of a computer system 200 utilizing microprocessor 10 is shown In the depicted system, a mam memory 204 is coupled to bus bridge 202 through a memory bus 206, and a graphics controller 208 is coupled to bus bridge 202 through an AGP bus 210 Fmally, a plurality of PCI devices 212A-212B are coupled to bus bridge 202 through a PCI bus 214 A secondary bus bridge 216 may further be provided to accommodate an electncal interface to one or more EISA or ISA devices 218 through an EISA/ISA bus 220 Microprocessor 10 is coupled to bus bndge 202 through a CPU bus 224 Bus bridge 202 provides an mterface between microprocessor 10, mam memory 204, graphics controller 208, and devices attached to PCI bus 214 When an operation is received from one of the devices connected to bus bndge 202, bus bridge 202 identifies the target of the operation (e g a particular device or, m the case of PCI bus 214, that the target is on PCI bus 214) Bus bridge 202 routes the operation to the targeted device Bus bridge 202 generally translates an operation from the protocol used by the source device or bus to the protocol used bv the target device or bus In addition to providmg an interface to an ISA/EISA bus for PCI bus 214. secondary bus bridge 216 may further incorporate additional functionality, as desired For example, in one embodiment, secondary bus bridge 216 includes a master PCI arbiter (not shown) for arbitrating ownership of PCI bus 214 An input/output controller (not shown), either external from or mtegrated with secondary bus bridge 216, may also be mcluded within computer system 200 to provide operational support for a keyboard and mouse 222 and for vanous senal and parallel ports, as desired An external cache unit (not shown) may further be coupled to CPU bus 224 between microprocessor 10 and bus bridge 202 m other embodiments Alternatively, the external cache may be coupled to bus bridge 202 and cache control logic for the external cache may be mtegrated into bus bndge 202 Mam memory 204 is a memory in which application programs are stored and from which microprocessor 10 primarily executes A suitable mam memory 204 comprises DRAM (Dynamic Random Access Memory), and preferably a plurality of banks of SDRAM (Synchronous DRAM) PCI devices 212A-212B are illustrative of a vanety of penpheral devices such as, for example, network interface cards, video accelerators, audio cards, hard or floppy disk dnves or drive controllers, SCSI (Small ComDuter Systems Interface) adapters and telephony cards Similarly, ISA device 218 is illustrative of vanous types of penpheral devices, such as a modem, a sound card, and a variety of data acquisition cards such as GPIB or field bus mterface cards Graphics controller 208 is provided to control the rendering of text and images on a display 226 Graphics controller 208 may embody a typical graphics accelerator generally known in the art to render three- dimensional data structures which can be effectively shifted into and from mam memory 204 Graphics controller 208 may therefore be a master of AGP bus 210 in that it can request and receive access to a target interface withm bus bridge 202 to thereby obtain access to main memory 204 A dedicated graphics bus accommodates rapid retrieval of data from mam memory 204 For certain operations, graphics controller 208 may further be configured to generate PCI protocol transactions on AGP bus 210 The AGP interface of bus bndge 202 may thus include functionality to support both AGP protocol transactions as well as PCI protocol target and initiator transactions Display 226 is any electronic display upon which an image or text can be presented A suitable display 226 includes a cathode ray tube ("CRT"), a liquid crystal display ("LCD"), etc It is noted that, while the AGP, PCI, and ISA or EISA buses have been used as examples in the above description, any bus architectures may be substituted as desired It is further noted that computer system 200 may be a multiprocessing computer system mcludmg additional microprocessors It is still further noted that the present discussion may refer to the assertion of vanous signals As used herem, a signal is "asserted" if it conveys a value indicative of a particular condition Conversely, a signal is "deasserted" or "not asserted" if it conveys a value indicative of a lack of a particular condition A signal may be defined to be asserted when it conveys a logical zero value or, conversely, when it conveys a logical one value Additionally, various values have been described as being discarded m the above discussion A value may be discarded in a number of manners, but generally involves modifying the value such that it is ignored by logic circuitry which receives the value For example, if the value comprises a bit, the logic state of the value may be inverted to discard the value If the value is an n-bit value, one of the n-bit encodmgs may indicate that the value is invalid Setting the value to the invalid encoding causes the value to be discarded Additionally, an n-bit value I t may include a valid bit mdicative, when set, that the n-bit value is valid Resetting the valid bit may compnse discarding the value Other methods of discarding a value may be used as well Industrial Applicability This invention is applicable to a number of different industrial fields, including, but not limited to microprocessors, computer systems, personal digital assistants (PDAs), computer networks, smgle and multiprocessor systems, systems-on-a-chip, embedded processor and microcontroller systems, and digital signal processors Numerous variations and modifications will become apparent to those skilled in the art once the above disclosure is fully appreciated It is mtended that the following claims be interpreted to embrace all such variations and modifications

Claims: WHAT IS CLAIMED: 1 A microprocessor (10) comprising a predecode unit (12) configured to receive mstruction bytes from a level two cache (50) and generate conesponding predecode information, and an instruction cache (16) coupled to the predecode unit (12), wherein the instruction cache (16) compnses a first plurality of storage locations (64) for storing instruction bytes and a second plurality of storage locations (62) for storing predecode information conesponding to the mstruction bytes, wherein the instruction cache ( 16) is configured to receive and store the mstruction bytes and the predecode mformation from the predecode unit (12), wherein the instruction cache (16) is configured to output at least part of the conesponding predecode information for storage in the level two cache (50) when the mstruction bytes and conesponding predecode information are replaced 2 The microprocessor (10) as recited in claim 1, wherein the predecode unit (12) is further configured to receive predecode information conesponding to the instruction bytes from the level two cache (50) 3 The microprocessor (10) as recited in claim 2, wherein the predecode unit (12) is configured to generate predecode information for the instruction bytes when the predecode unit (12) receives predecode information from the level two cache (50) that equals a predetermmed invalidation constant 4 The microprocessor (10) as recited m claim 1, wherein the mstruction cache (16) is configured to output the conesponding predecode information to storage locations (60) within the level two cache (50) that are designated to store parity or enor checking and conection information 5 The microprocessor (10) as recited in claim 1, wherein the predecode mformation includes instruction length information 6 A method for speeding instruction predecode compnsing reading instruction bytes from a main system memory, generating predecode information that conesponds to the instruction bytes, stormg the instruction bytes and predecode information in an mstruction cache (16), and outputtmg at least a portion of the predecode information to a level two cache (50) for storage when the instruction bytes conesponding to the predecode information are overwntten m the instruction cache (16) 7 The method as recited in claim 6, wherein the outputtmg comprises outputtmg the predecode mformation to a level two cache (50) for storage in storage locations (60) configured to store parity or enor checkmg and conection mformation 8 The method as recited in claim 6, wherein the predecode information comprises instruction length mformation 9 The method as recited m claim 6, further compnsmg initializing the predecode mformation stored m the level two cache (50) by stormg an invalidation constant mto the level two cache (50) 10 The method as recited in claim 6, further compnsmg recalculating the predecode information in the event the conespondmg instruction bytes are modified 11 A computer system (200) configured to store predecode information compnsmg a level two cache (50), and a microprocessor (10) coupled to the level two cache compnsing a predecode unit (12) configured to receive instruction bytes from the level two cache (50) and generate conesponding predecode information, and an mstruction cache (16) coupled to the predecode unit (12), wherem the instruction cache (16) compnses a first plurality of storage locations (64) for stormg mstruction bytes and a second plurality of storage locations (62) for stormg predecode information conesponding to the mstruction bytes, wherem the mstruction cache (16) is configured to receive and store the mstruction bytes and the predecode mformation from the predecode unit ( 12), wherein the mstruction cache (16) is configured to output at least part of the conespondmg predecode mformation for storage in the level two cache (50) when the mstruction bytes are replaced 12 The computer system (200) as recited m claim 11, wherem the level two cache (50) comprises a plurality of instruction storage locations (58) and a conesponding plurality of parity storage locations (60), wherein the level two cache (50) is configured to store the predecode information in the parity storage locations (60) 13 The computer system (200) as recited in claim 12, wherem the level two cache (50) further comprises a plurality of enor checking and conection storage locations (60), wherem the level two cache (50) is further configured to store a portion of the predecode information in the enor checking and conection storage locations (60).

Inventors: MAHALINGAIAH RUPAKA, MAHALINGAIAH, RUPAKA
Applicants: ADVANCED MICRO DEVICES INC, ADVANCED MICRO DEVICES, INC.
Application year: 1999
Main classification: G06F9
IPC codes: G06F9, G06F11, G06F12