Abstract:
A processor for executing a code sequence that includes multiple function calls comprising a register file having a predetermined size and a means for allocating sets of registers on a per-function call basis. A reserve storage area is included and a means for saving a particular set of registers in the reserve storage area responsive to a function call that would overflow the predetermined size of the register file.

Description:
FIELD OF THE INVENTION  
         [0001]    The present invention relates generally to the field of microprocessors; more particularly, to cache memories and cache memory hierarchies for use in improving the performance of processor-based computer systems.  
         BACKGROUND OF THE INVENTION  
         [0002]    The push for higher performance levels in modern microprocessors has led to the development of new optimization techniques in architectural extensions. These features include speculation, predication, larger register files, a register stack, and an advanced branch architecture. Proposed architectural extensions provide for 64-bit capabilities. One way that new architectural features can enable high performance in future processor implementations is in the handling of high performance procedural calls and returns, which require all parameters between the calling and called procedures to be passed through registers. In traditional architectures, procedure calls retard performance since registers must be spilled and filled repeatedly. By way of example, as nested and recursive calls are encountered in a program, additional registers may need to be allocated to the parameter stack, which will eventually overflow the physical register file size. This condition has created a need for new procedures and apparatus to communicate register usage to the processor. It is desirable in new architectural extensions to avoid the unnecessary spilling and filling of registers at procedure call and return interfaces.  
         SUMMARY OF THE INVENTION  
         [0003]    The present invention provides a processor for executing a code sequence that includes multiple function calls comprising a register file having a predetermined size and a means for allocating sets of registers on a per-function call basis. Additionally, a reserve storage area is included and a means for saving a particular set of registers in the reserve storage area responsive to a function call that would overflow the predetermined size of the register file.  
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0004]    The present invention is illustrated by way of example, and not limitation, in the figures of the accompanying drawings, where:  
         [0005]    [0005]FIG. 1 illustrates a mapping of register stack frames into a set of physical registers in accordance with the present invention.  
         [0006]    [0006]FIG. 2 shows one possible implementation of the backing store memory format in accordance with one embodiment of the present invention.  
         [0007]    [0007]FIG. 3 is an example showing the operation of one embodiment of the present invention.  
         [0008]    [0008]FIG. 4 illustrates various regions the register stack engine in accordance with one embodiment of the present invention.  
         [0009]    [0009]FIGS. 5A and 5B show an example of register stack overflow.  
         [0010]    [0010]FIGS. 6A and 6B show the backing store states corresponding to FIGS. 5A and 5B, respectively.  
         [0011]    [0011]FIGS. 7A and 7B show an example of register stack underflow.  
         [0012]    [0012]FIGS. 8A and 8B show the backing store states corresponding to FIGS. 7A and 7B, respectively.  
     
    
     DETAILED DESCRIPTION  
       [0013]    Throughout the following description specific details are set forth in order to provide a more thorough understanding of the invention. However, the invention may be practiced without these particulars. In other instances, well known elements have not been shown or described in detail to avoid unnecessarily obscuring the present invention.  
         [0014]    A new processor is described with an apparatus that improves performance by implementing a register stack engine (RSE) mechanism that operates concurrently with a backing store memory. This mechanism avoids the unnecessary spilling and filling of registers which typically occurred in traditional architectures during procedure calls. The invented processor enables procedures to communicate register usage to the processor through compiler-controlled renaming.  
         [0015]    At a call site, a new frame of registers is made available to the called procedure without the need for register spill and fill (either by the caller or by the callee). Register access occurs by renaming the virtual register identifiers in the instructions through a base register into the physical registers. The callee can freely use available registers without having to spill and eventually restore the caller&#39;s registers. The callee executes an allocate (i.e., alloc) instruction specifying the number of registers it expects to use in order to ensure that enough registers are available. If sufficient registers are not available (i.e., stack overflow), the alloc stalls the processor and spills the caller&#39;s registers until the requested number of registers are available. In essence, the RSE operates to take advantage of unused memory bandwidth to dynamically issue register spill and fill operations. In this manner, the latency of register spill/fill operations is overlapped with useful program work.  
         [0016]    According to the embodiment of the present invention shown in FIG. 1, the register stack frames are mapped into the set of physical registers  10  which operate as a circular buffer (indicated by dashed line  17 ) containing the most recently created frames. The physical registers are utilized to pass parameters between the calling and the call procedures being executed by the program running on the processor. As nested and recursive calls are encountered, additional registers are allocated to the parameter stack, which may eventually overflow.  
         [0017]    One of the functions of the register stack engine is to perform a backing store operation to a backing store memory  20  to save and restore registers that would overflow the physical register file size. The RSE moves the contents of registers between the physical register stack  10  and the backing store memory  20  without explicit program intervention. In the current implementation, the backing store memory  20  comprises a dedicated cache that is optimized for the particular memory access pattern of the RSE. By implementing the backing store as a dedicated cache, the backing store traffic does not interfere with the normal execution traffic of the processor. The operation of spilling/filling between the physical registers and the backing store is accomplished through ordinary logic, which may be associated with the cache memory.  
         [0018]    With continuing reference to FIG. 1, the RSE operates on the physically stacked registers outside of the currently active frame as defined by a current frame marker. As indicated in FIG. 1, frame  14 , which contains the registers associated with procedure C (i.e., proc C) is the currently active frame. The registers outside of the currently active frame contain the frames of the parent procedures of the current procedure. In FIG. 4, these registers are the registers of frames  12  and  13  associated with proc A and proc B, respectively. Physical register stack  10  is also shown having two unallocated sets of registers  11  and  15 . Unallocated registers  11  are defined in one embodiment as global registers, meaning that they do not get overwritten and they do not change context from procedure to procedure. Unallocated registers  15  represent the available register space that exists in physical register stack  10 .  
         [0019]    The embodiment of FIG. 1 shows backing store memory  20  organized as a stack that grows from lower to higher memory addresses. A backing store pointer (BSP) application register, denoted in FIG. 1 as AR[BSP], is utilized to store the address of the first (i.e., lowest) memory location reserved for the current frame. In other words, this represents the location at which the registers associated with the current frame are spilled. RSE spill/fill activity occurs at addresses below what is contained in the BSP since the RSE spills/fills the frames of the current procedure&#39;s parents. A second application register, denoted AR[BSPSTORE], contains the address at which the next RSE spill will occur. Note that the address register which corresponds to the next RSE fill operation, BSP load pointer, is not architecturally visible.  
         [0020]    Also illustrated in FIG. 1 by arrows  18  are RSE loads/stores. The RSE load/store operations transfer the contents between the physical registers  10  and the backing store memory  20 . Accordingly, backing store memory  20  contains a set of addresses  22  corresponding to the contents of registers in frame  12 , and also a second set of memory addresses  23  that store the contents of frame  13  from the physical stack.  
         [0021]    Referring now to FIG. 2, there is shown one possible implementation of the backing store memory format. Within each stacked frame, lower-addressed registers are stored at lower memory addresses. Note that the RSE also spills/fills the NaT bits corresponding to the stacked registers. (The NaT bits are the 64th bit of each general register.) When the RSE spills a register to the backing store, the corresponding NaT bit is copied to the RSE NaT collection application register.  
         [0022]    Whenever bits 8:3 of BPSSTORE application register are all 1&#39;s, the RSE stores the NaT collection application register to the backing store. As shown in FIG. 2, this results in a backing store memory image in which every 63-register value is followed by a collection of NaT bits. When the RSE fills a stacked register from the backing store it also fills the register&#39;s NaT bit. Whenever bits 8:3 of the RSE backing store load pointer are all 1&#39;s, the RSE reloads a NaT collection from the backing store.  
         [0023]    As previously discussed, the RSE operates concurrently and asynchronously with respect to instruction execution to dynamically perform registers spill and fill operations. The algorithm employed by the RSE to determine whether and when to spill/fill is implementation dependent.  
         [0024]    To better understand and appreciate the present invention, consider the following example. Assume that at the beginning of a program or code sequence, that all registers in the physical register stack are available. That is, all of the registers are totally unused. As the program calls a first procedure (proc A), the RSE allocates the appropriate number of registers required for the procedure. As shown in FIG. 3, proc A requires 16 registers R32-R47 to proc A. Recall that registers R0-R31 are addressed as global registers in physical register stack  10 . Internally, proc A views the allocated registers as R32-R47 as well. (Note that there is a pointer in the RSE that indicates the place in physical stack register  10  where the next allocation begins.)  
         [0025]    Further assume that proc A calls a second procedure, proc B, which requires, say, another 16 registers, for example. To accommodate proc B, the RSE of the processor allocates another 16 registers of the physical register stack  10 —R48-R63—and dedicates these registers to proc B. The mapping occurs in such a way that, internally, proc B refers to these registers as R32-R47 (with R0-R31 being addressed within proc B as the global register set).  
         [0026]    At the same that the RSE allocates registers for the various procedures and maintains pointers to the next available registers, the RSE also manages the backing store cache memory  20 . As the register pressure builds and more and more registers are used up by the program being executed, the RSE starts saving the contents of the registers that were used previously into the backing store memory. As shown in FIG. 3, the contents of the registers associated with the various procedures are stored in the cache memory in a stack fashion.  
         [0027]    As the processor deallocates register usage—by completing a task associated with the procedure and returning—the RSE then frees register space by marking the previously used registers as being available once again. Registers are made available when the procedure that was utilizing the registers is no longer in context.  
         [0028]    [0028]FIG. 3 is an example showing the operation of one embodiment of the present invention. The example illustrates how each time a procedure is called a new procedure stack is allocated, since a procedure can be called multiple times with different arguments. This is also true for recursive function calls. In the example of FIG. 3, proc C is called by proc B, however, proc C recursively calls back proc A, as indicated by arrow  30 . In this case, if the registers associated with proc A had already been saved into memory  20 , the RSE restores the contents of that register set. In other words, RSE keeps a list of which procedures are active and the status of the procedure (i.e., whether in memory or in the physical register stack). The list may be stored in a variety of ways, such as an ordinary table memory, a reserved set of register space, or other common storage locations.  
         [0029]    In one possible implementation, the RSE operates in a “eager mode” in which the RSE speculatively is working ahead of program execution. The eager mode attempts to anticipate when the register stack will overflow, and begins actively saving those registers into memory  20  in anticipation of an overflow condition. A simple high/low “water mark” indicator can be utilized to trigger the register saving operations. Once a certain number of registers have been filled up in the physical register stack, the RSE&#39;s eager mode of operation will begin saving the contents of those registers to the cache memory.  
         [0030]    Note that this implementation is not limited in the sense that a variety of different prediction or saving algorithms may be employed. Practitioners in the art will clearly appreciate that the micro-architecture of the processor does not necessarily have to implement eager mode of operation. Similarly, although the processor of the present invention is advantageously implemented with an RSE dedicated cache to alleviate normal RSE bus traffic, this is simply one micro-architectural scheme. Broadly speaking, the present invention encompasses a virtual memory scheme for registers. In other words, the backing store memory can be implemented in a variety of different manners.  
         [0031]    Another possibility is to implement a mode in which the RSE only operates synchronously with respect to instruction execution—that is, only on program demand. This is known as a “lazy mode” of operation. In such a mode, software cannot assume anything about the behavior of the spill/fill algorithm used by any particular implementation.  
         [0032]    It will be further appreciated that the sizing of the backing store cache is dependent on processor design considerations. One way to implement the cache memory size is to perform certain performance analysis tests on the processor to see how large the cache memory should be, waiving the performance benefits against the cost in terms of silicon area. Ideally, it is desirable to make the cache memory on the same chip as the processor. In that way, the data can be saved and restored quickly without interfering with normal processor data/instruction fetch traffic.  
         [0033]    Table I describes the architectural state that is maintained internally by the register stack engine. The RSE internal state elements described in Table I are not exposed to the programmer as architecturally visible registers. As a consequence, RSE internal state does not need to be preserved across context switches or interruptions. Instead it is modified as the side effect of register stack-related instructions. To distinguish them from architecturally visible resources, all RSE internal state elements are prefixed with “RSE”.  
                   TABLE I                       NAME   DESCRIPTION                   RSE.N_STACKED_PHYS   Implementation - dependent size of the           stacked physical register file       RSE.BOF   Bottom of frame register number.           Corresponds to the memory location           pointed to by AR[BSP]       RSE.TOF   Top of frame register number       RSE.StoreRegNum   The physical register number of the next           register to be stored by RSE.           Corresponds to the memory location           pointed to by AR[BSPSTORE}       RSE.LoadRegNum   Physical register number one greater           than the next register to load.           Corresponds to memory location           pointed to by RSE.BSPLOAD       RSE.BSLOAD   Backing store pointer for memory           loads. Corresponds to stack register           pointed to by RSE.LoadRegNum       RSE.RNATBitIndex   b-bit wide RNAT Collection Bit Index           (defines which RNAT collection bit gets           updated). Equal to AR[BSPSTORE] {8:3}       RSE.CFLE   RSE Current frame load enable bit           that allows the RSE to load registers into           the current frame after a branch return                  
 
         [0034]    The minimum number of stacked physical registers that an implementation may provide is equal to the architecturally defined size of the stacked register file, which in one embodiment is 96 registers. The stacked set of registers comprises four different regions. The first region is a “clean” region in which the registers contain values from parent procedure frames. These registers have been successfully spilled to the backing store by the RSE, and their contents have not been modified since they were written to the backing store. The clean region begins with the register pointed to by RSE.LoadRegNum and continues up to, but not including, the register pointed to by RSE.StoreRegNum. The corresponding locations of the backing store begin with the address RSE.BSPLOAD and continue up to, but not including, the address stored in application register AR[BSPSTORE].  
         [0035]    Note that if RSE.LoadRegNum is equal to RSE.StoreRegNum, then the clean region is empty (i.e., RSE.BSPLOAD=AR[BSPSTORE]).  
         [0036]    The second region is the “dirty” region in which the registers contain values from previous procedure frames. These registers have not yet been spilled to the backing store by the RSE. The dirty region beings with the register pointed to by the RSE.StoreRegNum and continues up to, but not including, the register pointed to by RSE.BOF. The corresponding locations on the backing store start with address AR[BSPSTORE] and continue up to, but not including, AR[BSP]. Note that if RSE.StoreRegNum is equal to RSE.BOF, then the dirty region is empty (AR[BSPSTORE]=AR[BSP]). The active region contains registers allocated to the current stack frame.  
         [0037]    The third region, the “active” region, beings with the register pointed to by RSE.BOF and continues up to, but not including, the register pointed to by RSE.TOF.  
         [0038]    Finally, the “invalid” region is reserved for registers outside the current frame not belonging to any previous procedure frame. These registers are immediately available for allocation by the current procedure, or for eager RSE fill operations. The invalid region begins with the register pointed to by RSE.TOF and continues up to, but not including, the register pointed to by RSE.LoadRegNum. If RSE.TOF is equal to RSE.LoadRegNum, then the invalid region is empty. An illustration of the register stack and various regions is shown in FIG. 4.  
         [0039]    Note that the registers can be viewed as a circular buffer. The register pointers RSE.LoadRegNum, RSE.StoreRegNum, RSE.TOF, and RSE.BOF wrap around the stack when incremented above the top, or decremented below the bottom, of the physical stacked register set.  
         [0040]    Consider the case where a program requests a new stack frame, which is larger than the current frame with an alloc instruction. Recall that the clean region of the stack contains those registers whose values are preserved, having been written to the backing store above the RSE; the invalid region of the stack contains those registers whose values are not part of any previous procedure stack frame. Any register belonging to either of these two regions may be allocated to the new stack frame without any mandatory spill or fill operations being performed by the RSE. The reason why is because any clean registers that are allocated into the new frame may be restored later by reloading their values from the backing store.  
         [0041]    Furthermore, any invalid registers that are allocated to the new frame do not contain useful values. When the program requests a new stack frame with an alloc instruction, and the register stack is unable to supply enough registers for the new frame from the combined pool of clean and invalid registers, the RSE suspends subsequent instruction execution and spills enough registers from the dirty region of the register file to satisfy the programs request. This condition is known as overflow.  
         [0042]    [0042]FIGS. 5A and 5B show an example of register stack overflow. FIG. 5A shows the register stack state prior to an alloc instruction. FIG. 5B shows the register stack state once the alloc instruction has been executed, but before the registers have been spilled from the dirty region. One can imagine overflow as the encroachment of the active region onto the dirty region, where the clean and invalid regions snap to the top of the active frame. The clean and invalid regions have their sizes set to zero since the registers have been allocated to the new active frame.  
         [0043]    [0043]FIGS. 6A and 6B show the backing store states corresponding to FIGS. 5A and 5B, respectively. When the overflow condition is resolved, i.e., when the RSE has filled all the necessary registers, RSE.StoreRegNum is equal to RSE.LoadRegNum, and AR[BSPSTORE] is equal to RSE.BSPLOAD.  
         [0044]    Next consider the case where the program deallocates the current stack frame by returning to a previous frame, e.g., via a branch return. For a branch return, growth is typically negative, but it does not have to be this way. The registers being deallocated are added to the invalid region since they are not longer part of the active frame, nor do they contain valid values belonging to any previous frame.  
         [0045]    The register stack regions “below” RSE.BOF are the dirty region, the clean region, and the invalid region, in that order. If RSE.BOF drops by an amount such that its new value falls into either the dirty or clean regions, then no mandatory spills or fills are required since the dirty and clean regions contain valid register values from previous stack frames. If RSE.BOF drops by an amount such that its new value falls into the invalid region, and the number of registers in the new stack frame will contain invalid values. The RSE then halts subsequent instruction execution and fills these registers from the backing store. This condition is known as underflow. FIGS. 7A and 7B show an example of register stack underflow. FIG. 7A shows the condition of the stack prior to branch return, with FIG. 7B illustrating the state of the register stack after branch return. FIGS. 8A and 8B show the backing store states corresponding to FIGS. 7A and 7B, respectively.