EP0106667A2

EP0106667A2 - Central processing unit

Info

Publication number: EP0106667A2
Application number: EP83306189A
Authority: EP
Inventors: Leonard G. Trubisky; William A. Shelley
Original assignee: Honeywell Information Systems Italia SpA; Honeywell Information Systems Inc
Current assignee: Bull HN Information Systems Italia SpA; Bull HN Information Systems Inc
Priority date: 1982-10-13
Filing date: 1983-10-13
Publication date: 1984-04-25
Also published as: FI833637A; KR840006528A; AU1879283A; FI833637A0; DE3377678D1; FI80532C; ES526393A0; ES8406756A1; EP0106667B1; JPS5991546A; FI80532B; EP0106667A3; US4521851A; AU555456B2; CA1200318A; KR880002660B1

Abstract

A central processor for a general-purpose digital data processing system. The processor has a pair of caches, an operand cache for operands and an instruction cache for instructions, as well as a plurality of execution units, where each execution unit executes a different set of instructions of the instruction repertoire of the central processor. An Instruction fetch unit fetches instructions from the instruction cache and stores them in an instruction stack. The central pipeline unit which has five stages obtains instructions in program order from the instruction stack of the instruction fetch unit. In the first stage of the central pipeline unit, the instruction is decoded; in the second, the address preparation of an operand whose address is included in the instruction is initiated; in the third cycle, the address preparation is completed and the operand cache is accessed; in the fourth cycle, the operand is selected from the operand cache; and, in the fifth cycle, the instruction and operand are transmitted to the one of the plurality of execution units capable of executing the instruction. The results of the execution of each instruction by each execution unit are stored in a results stack associated therewith. A collector unit causes the results of the execution of the instructions to be stored in a master safe store register in program order, which is determined by the order of issuance of the instructions by the central pipeline unit. The collector also issues write commands which cause the results of the execution of an Instruction to be written Into the operand cache.

Description

This invention is in the field of general-purpose digital data processing systems having a central processor which is optimized to achieve maximum throughput.
Typically, in large-scale, general-purpose digital data processing systems, the central processor of such a system includes circuits for producing the addresses of instruction words in the memory of the system, for fetching the instructions from memory, for preparing the addresses of operands, for fetching the operands from memory, for loading data into designated registers, for executing the instructions, and, when the results are produced, for writing the results into memory or into program-visible registers.
To increase the performance of the processors and of the systems as a whole, i.e., throughput, of data processing systems, various modifications have been incorporated into the central processing units. To reduce the time required to obtain operands and instructions, high-speed caches located in the processor have been provided. To speed up the systems, the systems are synchronized, i.e., a clock produces clock pulses which control each step of the operation of the central processing unit. In pipelined processors, the steps of preparing and fetching the instructions and operands are overlapped to increase performance .
However, there is always a need for more or greater throughput and preferably without changing the instruction repertoire or the internal decor of the processors of such systems so that such high-performance processors are capable of executing existing programs without the necessity for such programs to be modified or changed, or such processors are compatible with the programs written for earlier systems.
Accordingly the present invention provides a central processor for a general purpose digital data processing system, characterized by:

cache means adapted to store instructions and operands;
a plurality of instruction execution units, each of which is adapted to execute a different set of the instructions; instruction fetch means for fetching instructions from the cache means and for queuing instructions awaiting execution; central unit means for obtaining instrictions from the instruction fetch means, for decoding the instructions, preparing the address of an operand to be operated upon by the instruction, checking to determine if the addressed operand is stored in the cache means, accessing the addressed operand from the cache and dispatching the instruction and its operand to one of the execution units; and
collector means for receiving the results of the execution of each instruction from the execution units in program order and for writing into the cache means the results of the execution of instructions which are to be written into memory.

A central processing unit embodying the invention will now be described, by way of example, with reference to the drawings, in which:-

Figure 1 is a block diagram of the central processing unit; and
Figure 2 is the format of an instruction word.

INTRODUCTORY SUMMARY

The present invention provides a high throughput synchronous central processor for a large-scale, general-purpose digital data processing system. The processor is provided with a cache unit which has an operand portion, or operand cache, in which primarily operands are stored, and an instruction portion, or instruction cache, in which primarily instructions are stored. The processor has a given repertoire of instructions and a plurality of execution units. Each of the execution units has the capability of executing a different set of instructions of the instruction repertoire. An instruction fetch circuit fetches instructions primarily from the instruction cache and stores them in an instruction stack. The central pipeline unit, a five-level, or stage, pipeline obtains instructions from the instruction stack in program order. In the first stage or first step of the central pipeline, the instruction is identified and the initiation of the preparation of an address of an operand using the address information portion of the instruction is started; in the second stage, the address of the operand is completed; in the third stage, the address is converted from a virtual memory address space representation to the actual physical address space representation, and a set of candidate operands is accessed from the operand cache along with the physical page number identifying the system memory location from which each of the operand candidates was accessed; in the fourth stage, the operand page number portion of the physical address is compared with the page number associated with each of cache accessed operand candidates;and assuming there is a match, in the fifth step, the selected operand and execution command code are transmitted to the execution unit uniquely capable of performing the instruction. At the same time, the instruction code is transmitted to the collector. As the instructions are sent to the execution units, they are executed or are held in an input stack awaiting their turn to be executed in that unit. The instructions are executed in the order received by each execution unit. Each of the execution units performs its operations independently and in parallel with one another. Therefore, instructions sent to different execution units may not be completed in the same time sequence as originally fetched from cache. Each of the instruction units is provided with a results stack into which is placed the results of the execution of the instructions by that unit. The collector fetches these results from the appropriate execution unit in program order and places them in the collector's master safe store or its store stack. The master safe store maintains a valid copy of all of the program-visible registers of the central processor unit. The data to be written into memory is placed in the store stack prior to being written into the operand cache where it remains for use or further modification until displaced or needed by other units of the system of which the processor is a part. The modified data upon displacement or system demand is then written into the random-access memory of the system of which the CPU is a portion.

DETAILED DESCRIPTION

Figure 1 shows the major subsystems of a central processing unit 10. The central pipeline unit structure 12 controls the overall operation of processor 10. The instruction fetch unit 14 supplies the addresses of instruction words to instruction cache 16. In response to the instruction address being applied to the instruction cache 16 from instruction fetch unit 14, an instruction double word is transmitted from cache 16 to instruction fetch unit 14 which stores a series of instructions in an instruction stack which is a part of the instruction fetch unit 14. The central pipeline unit 12 obtains the instructions in program order from the instruction stack of instruction fetch unit (IFU) 14, preferably one per clock period of the system clock of processor 10. The central pipeline unit structure 12 is a 5-stage pipeline in which in the first stage the operation code is decoded and formation of the operand's address is started using an 18 bit Y portion and a 6 bit TAG portion of the instruction. In the second stage, the address formation is completed. In the third and fourth stages, the directory of operand cache 20 is searched to determine if the operand is located in the cache, and the operand is accessed or obtained from the cache data storage. However, if the operand is not stored in the cache, than a block of eight words which contains the operand is fetched from main memory 22 and stored in the operand cache after sending the desired operand to the distributor. In the fifth stage, distributor 24 distributes each instruction and its operand to the appropriate execution units: the central execution unit CEU 26, the virtual memory and security manager VMSM 28, the binary arithmetic execution unit BINAU 30, or the decimal character unit DECCU 32. In addition, the instructions and other relevant information, as will be described hereafter, are transmitted in program order to the instruction execution queue 34 of collector 36.
Each of the execution units 26, 28, 30, and 32 is capable of receiving instructions and operands and of processing them independently of any other execution unit. Each of the execution units includes logic circuits which are optimized for performing the set of instructions assigned to it. Central execution unit 26 performs basic computer operations, such as simple loads, adds, subtracts, etc., and certain miscellaneous instructions. The central execution unit 26 is unique among the four execution units in that it executes each instruction as received, usually within one block period. Central execution unit 26 is therefore not provided with an input stack as are the other execution units illustrated in Figure 1. The virtual memory and security manager unit 28 executes instructions relating to virtual memory, security and special instructions that are peculiar to a secure operating system. The BINAU execution unit 30 executes binary arithmetic instructions, such as multiply, divide and floating point instructions. The decimal/character execution unit 32 executes alphanumeric, decimal arithmetic, and bit string instructions. Execution units 28, 30, and 32 have respective input stacks 38, 40, and 42, the function of which is to store the operation code and operands of the instructions awaiting execution by the associated execution units.
Each of the input stacks 38, 40, and 42 is a conventional FIFO (first-in, first-out) stack having 16 levels, with each level adapted to store a double data word (two operands). In addition, an execution code derived from the operation code of the instruction word to be performed or executed is stored with the operand in the input stack. The input stacks are FIFO stacks, so that the first operation code and operand required for each operation code applied to a given execution unit is the first one read out of the input stack for execution by that unit.
Each of the execution units has also a respective results stack 44, 46, 48, and 50. The results stacks are conventional FIFO stacks, each of which has 16 levels. The results of the operation of an instruction are stored in the stacks in the order in which they are executed. Each level of a results stack has the capability of storing a double word, as well as additional information with respect to the double word. The operational code of each instruction word in execution, along with other information, is a part of an instruction execution queue word (IEQ) which is stored in the execution queue 34 which is a conventional FIFO stack of 16 levels.
An important feature of the processor unit 10, from the standpoint of performance, is that both the operand cache 20 and the instruction cache 16, which together form a cache unit, and the main memory 22 perceive the addressed space as being composed of blocks of eight 36-bit words. All data transfers between the main memory and the caches 20 and 16 are in units of such blocks of 8 words. Movement of data within the processor unit 10, particularly between the cache units and the execution units, is on a double word, or pair, basis and only the double word required is so moved. The distributor 24 supplies operands from the cache 20 to the various execution units and maintains multiple copies of the AQ register, one set for the central pipeline unit structure, the BINAU and the DECCU. The instruction fetch unit 14 consists of an instruction prefetch pipeline of five stages. Instruction prefetch unit 14 stores prefetched instructions and data in its instruction stack. The instructions represent the current instruction stream and one or more prefetched alternative streams or indirect words predicated by the transfer/indirect prediction table of unit 14. The instruction fetch unit supplies instructions to the central pipeline unit 12. In central pipeline unit 12, instructions are decoded during the I, or instruction, cycle of central pipeline unit 12. Instruction prefetch pipeline 14 does not examine the instruction operation codes of instructions prefetched by it, but rather uses the instruction count of its instruction counter register to search the transfer and indirect prediction table to determine if a given instruction is a branch to a new memory location or is an instruction requiring indirect addressing.
The instruction prefetch pipeline provides the instruction execution pipeline 12 with a supply of instructions to be executed. This is accomplished by use of a transfer and indirect prediction table to predict new instruction sequences and then to prefetch the instructions of the new instruction stream, two words at a time, from the instruction cache or occasionally from the operand cache and placing such instructions or indirect words in the instruction stack. Loading such new instruction sequences into the prefetch instruction stack occurs only if the transfer/indirect prediction table indicates that one such instruction of each pair was a successful transfer or required an indirect cycle the previous time the instruction was executed. When this occurs, instruction prefetch pipeline 14 diverts the current instruction sequence to fetch the targer word of the transfer instruction or indirect instruction. Otherwise, the instruction prefetch pipeline continues sequentially fetching instructions and placing them in its instruction stack. The instruction prefetch pipeline of instruction fetch unit 14 also returns to sequential prefetching if the predicted transfer instruction turns out to be a nontransfer when the instruction in question is actually executed. The prefetched transfer or indirect targets are available for processing by the central unit pipeline structure 12 as soon as they are fetched and stored in the instruction stack of the instruction fetch unit 14. Thus, it is not necessary to wait for the actual execution of a transfer or indirect instruction by the central pipeline structure unit to be completed before IFU 14 starts placing instructions of the new instruction stream in the instruction stack of IFU 14. In this way, the effective execution time of transfer instructions and instructions with indirect operands is minimized.
The instruction prefetch pipeline operates in five cycles in a manner similar to the five cycles of the central pipeline unit 12. One difference is that IFU 14 disposes of instructions by placing them in its instruction stack a double-word pair at a time whereas CUPS 12 disposes of instructions one word at a time by forwarding them to central execution unit 26 or to the input stacks of the execution units 28, 30, and 32. Another difference is that IFU 14 checks with its transfer/indirect prediction table to determine if a transfer or indirect address is to be executed, whereas the central pipeline unit structure updates the transfer/indirect prediction table of IFU 14. During the first cycle or stage of the instruction prefetch pipeline of ICU 14, the instruction counter of CPU 10 is incremented by 2. During the second cycle, the address of an instruction pair is distributed to the transfer/indirect prediction table and the instruction operand caches. During the third cycle, the transfer/indirect prediction table and instruction cache 16 are accessed. The instruction cache access consists of a set of 4 double words plus a physical page address denoting the physical system memory location associated with these double words. During the fourth cycle, the physical page address of the desired instruction pair is compared with the page address of each of the cache-accessed double words. If a match occurs, the double word associated with the match is selected as the instruction double word. If no match occurs, the operand cache is searched for the instruction double word. If the instruction double word is found neither in the I cache nor the O cache, an 8-word block containing the desired instruction double word is fetched from the main memory 10 and placed in the instruction cache.
The transfer/indirect prediction table is accessed in order to see if either or both of the instructions being accessed is predicted to be a transfer/go instruction during the compare/select or fourth cycle. The instruction pair is selected from one of the four cache levels corresponding to a match of the real page number from the directory of the current instruction stream. The instruction pair read out of the cache is saved in an instruction fetch register, the real page number is saved, and the response from the transfer/indirect prediction table is checked to see if either of the instructions is recorded in the transfer/indirect prediction table as a transfer/go. Note that the response from the transfer/indirect prediction table arrives two cycles after it is interrogated. During the execution cycle, the fifth cycle of the prefetch instruction pipeline, the instruction pair is placed in the instruction stack so that, if the transfer/indirect prediction table indicates that either of the instructions is a transfer, the instruction prefetch pipeline will prepare to fetch instructions from the new instruction stream. The timing is such that up to two extra double-word pairs from the current instruction stream will also be read from the cache. In the event the predicted transfer/go turns out to be a no go, the extra double-word pairs are still available in the instruction stack. Pointers associated with the instruction stack enable central instruction prefetch unit 12 to read instructions out of the instruction stack in the correct sequence, i.e., in program order.
The instruction stack functions as an instruction queue between instruction prefetch unit 14 and the instruction execution unit or central unit pipeline structure 12. The instruction stack is 15 levels deep. Once instructions or indirect words are placed in the instruction stack by the instruction fetch unit pipeline structure, they remain until they are executed or until it is determined that they are not to be executed. In the case of a transfer instruction or instructions requiring an indirect word for which a history is found in the transfer/indirect prediction table during prefetch, the instruction stack control contains a pointer to the instruction stack location holding the address of the target instruction, or of the indirect word. The instruction stack is a cyclic(round-robin) stack. There is a sixteenth entry which is used to buffer instruction double-word pairs. Instructions and indirect words or operands flow from the instruction stack if IFU 14 to the central pipeline unit structure 12 through the base instruction register of central unit 12 a single word at a time.
Central pipeline unit 12 also has five stages or cycles. In the first, the operation code of the instruction is decoded and formation of the operand address is started; in the second, the operand address is completed; in the third, the address is converted from a virtual memory address space representation to the actual physical address space representation, and a set of candidate operands is accessed from the operand cache along with the physical page number identifying the system memory location from which each of the operand condidates was accessed; in the fourth, the operand page number portion of the physical address is compared with the page number associated with each of cache accessed operand candidates;and assuming there is a match, in the fifth, the selected operand and execution command code is transmitted to the execution unit uniquely capable of performing the instruction. It should be mentioned that some of the activities carried out are skewed across the pipeline stages as defined. It is the central pipeline unit structure 12 that makes entries into the transfer/indirect prediction table of IFU 14. Whenever the central pipeline unit structure executes a transfer/go instruction, the central pipeline unit structure 12 verifies any corresponding entry which may be in the transfer/indirect prediction table. If a predicted transfer turns out to be a no-go or nontransfer, then that entry in the TIP table is deleted. In the case of an impure procedure, for example, the target address of the transfer instruction has been modified, but the operat_- ional code still remains a transfer; the appropriate entry in the transfer/indirect prediction table is corrected to reflect this fact. In the event of a transfer-go not previously recorded, a new entry is made in the TIP table which may displace another entry should all four levels corresponding to the instruction counter for that particular instruction be occupied. The displacement algorithm is random since there is little benefit in adding the necessary complex circuitry to displace the least recently used entry because of the infrequency of transfer/indirect prediction table misses. The central unit interacts with the transfer/ indirect prediction table in other ways. In the case of impure procedure where the operation code is changed but the transfer/indirect prediction table still predicts a transfer, the central pipeline unit structure 12 will detect the fact in the instruction cycle where the instruction is first decoded. In the case of indirect instructions, the central pipeline unit structure 12 also makes an entry into the transfer/indirect prediction table for these. The instruction execution pipeline 12 has the critical role in central processor 10 in achieving the necessary high levels of performance as any interruptions due to data not being in the cache unit, unexpected transfers, etc., will halt the operation of the central pipeline unit until such occurrences are remedied.
The transfer/indirect prediction table consists of 4,096 entries which are divided into 1,024 sets of four entries each. The TIP table serves to record the target address for the first level of indirection and also to predict the target address for both conditional and unconditional transfers. During the first execution of a successful; i.e, transfer-go instruction or an instruction requiring an indirect word, there will be a break in the pipeline of the central pipeline structure, while the target address is formed and the target accessed from the cache. On the first execution, information is prepared for the transfer/indirect prediction table defining the location of the target instruction in the cache unit. During the next prefetch of the transfer instruction or instruction requiring an indirect word, the prefetch pipeline accesses the transfer/indirect prediction table and determines the target location in order to also prefetch the alternative instruction stream or indirect word. Checking the transfer or indirect instruction occupies only one clock period of the central pipeline unit in order to verify that the prefetch target address has not changed. During subsequent executions of any transfer instruction, the transfer/indirect prediction table entry is updated only if the transfer does not go as expected. The transfer/indirect prediction table keeps track of only one level of indirection. The cache addresses of indirect words are put in the TIP table only if the indirect words are not modified.
The cache unit consists of two separate 8K caches, instruction cache 16 and operand cache 20. Data is maintained in each cache on an eight-word block basis. A block consists of eight consecutive 36-bit main memory words, the first word of which has an address ending in binary 000. A reference to any word in a block causes the entire block to be read from main memory, unless the block is already in the appropriate cache. Any block in a cache is retained until it is displaced by another block or until it is cleared from the cache by a cache clearing instruction. The instruction cache 16 holds blocks of unmodified instructions and indirect words, while the operand cache holds blocks of operands, modified instructions and indirect words. Operand data cannot be fetched from the instruction cache nor can data be modified in the instruction cache. It is possible to fetch instructions from the operand cache, but the normal and desired mode of operation is to fetch instructions from the instruction cache only. If a block which is contained in the instruction cache is referenced for a store or data fetch operation, that block is cleared from the instruction cache and refetched from main memory 22 and placed in the operand cache 20. In summary, operands are fetched only from the operand cache and they may be stored only into the operand cache. Instructions may be fetched from either cache, but there is a performance preference for the instruction cache.
Each cache has a four-level set associate directory for the accompanying storage for 8K 36-bit words. Each cache is organized as 256 rows of four 8-word blocks. The first eight words of physical memory map onto the first row of the cache, row 0. Words 8 to 15 on the second row, row 1, etc._', with words 2,040 to 2,047 mapping onto the last row, row 255. Each successive 2K of physical memory maps onto the cache in a similar manner. Hence, the cache row number of an eight-word block is known from its physical memory address. Since each row has space for four 8-word blocks, in four levels, the levels for a particular row in a given cache unit will be filled before there is a contention for space in that row. After all levels in the row have been filled, older blocks in the row are displaced on a least recently used basis. Thus, five hits to the same row are required before an incoming block of eight words can displace a prior block of eight. If an eight-word block of instructions is in the operand cache, instruction prefetch unit 14 can fetch the instructions from the operand cache a double-word pair at a time, but without removing them from the operand cache. Usually, the instruction prefetch unit runs far ahead of the instruction execution pipeline of the central pipeline unit structure 12, so this penalty is not always visible, but such a situation can cause an instruction prefetch pipeline to fall behind, in which case the lack of the proper instruction will result in a break in the pipeline unit structure.
Performance is enhanced by a store into cache as distinguished from a store through cache. All store operations go to the operand cache, but do not immediately go to main memory 22, although displacing the block in which the store occurred will force the writing of that block to main memory. If the block being stored into is already in the operand cache and control information indicates that the eight-word block has already been modified, then the store is completed to the operand cache and no further action is taken. However, if the block is found in the operand cache, but has not yet been modified, central processor unit 10 notifies the central interface unit associated with that block that the block is being modified. The CIU then issues a write notification to any other central processor units which may be present. These must then invalidate any copies of the eight-word block which they might have either in their operand cache or conceivably in their instruction cache. When a data block is not found in the operand cache on a store operation, the block is fetched from memory. Processor 10 indicates to the central interface unit that the fetch is for the purpose of modifying the block so that, when the processor receives the block, the block can be modified without any further communication between units. Only read cache misses cause the pipeline of the central pipeline unit structure to wait for data. On store cache misses, the pipeline continues without waiting for data.
Each cache has a duplicate directory, so that, when a system request is received to either clear a block or to transmit a block to system memory, the processor can search its duplicate cache directory to determine if the block is present without interfering with the operation of the central pipeline unit 12. If the requested block is found, then the processor takes the appropriate action. Otherwise, the duplicate directory responds to the request and the processor is not delayed.
The central unit pipeline structure 12 forwards the operation code of each instruction as it is received, in program order, to the instruction execution queue 34 for storage therein. Up to sixteen instruction execution queue I_EQ words can be stored in queue 34. Collector control 52 uses the operation code of each IEQ word to control the reading out of the results located or stored in the results stacks 44 to 50 of each of the execution units 26 to 32, so that the results in proper program order can be stored in either the master safe store MSS 54 or into store stack 56. Results that are stored in store stack 56 are for writes of operands to memory. Instructions which change program addressable registers of central processor 10 generate results that are stored in the master safe store 54 so that at such time as an interrupt, a fault, or a hardware error occurs, the contents of the program addressable registers of the central processor unit 10 are available in master safe store 54. The availability of current and valid contents of all program addressable registers greatly facilitates fault recovery, handling of interrupts, and retrying of instructions as appropriate. The main memory 22 of the data processing system of which the central processing unit 10 is a subsystem provides instructions for the instruction cache 16 and operands for operand cache 20. All stores or writes to main memory 22 are from data stored in the operand cache 20. Thus, whenever data is to be written into memory as a result of an execution of an instruction, the necessary data, operands, are stored in store stack 50 in program order and are issued or written into the operand cache 20 in program order. As a block of operand cache 20 is released so that new data can be written into that block, the operand cache control will have data in that block of cache written into main memory 22 before new data is written into that block.
The central pipeline unit 12 controls the overall operation of processor 10 and has the function of sending oper_- ation codes or commands and associated operands to the various execution units 26, 28, 30, 32, where the actual execution of each operand code is performed. Instruction fetch unit 14, under the control of the central pipeline unit 12, fetches instructions primarily from the instruction cache 16 and loads up to sixteen pairs of instructions in an instruction stack which is a part of unit 14. The central pipeline unit structure 12 obtains the instructions from the instruction stack of the instruction prefetch unit. The central pipeline unit 12 prepares the addresses of the operands in a series or sequence of five steps from the operand cache and sends the operation code and the operands to whichever one of the execution units 26, 28, 30, and 32 is capable of executing it. The instruction preprocessing, instruction decode, operand address formation, including paging and search of an associative memory of the operand cache, is performed within the central pipeline unit structure.
The execution units 26 to 32 receive commands from the central pipeline unit 12 and operands from the operand cache 20 which are distributed by distributor 24 to the various execution units. The execution of an instruction generally involves the formation of some result based upon current register contents and the input operand which produces a change to a program visible register or to memory.
Processor 10 is provided with four major execution units, each of which is made up of one or more subunits. These units are the central execution unit 26, the binary arithmetic unit which performs floating point and multiply and divide instructions BINAU 30, the decimal character unit DECCU 32, and the virtual memory and security manager unit VMSM 28. Each of the execution units 26 to 32 receives instructions and operands, and then processes them independently of what any of the other execution units may be doing. Execution units 28 and 30 each have an input stack 38 and 40, a sixteen-level FIFO stack with each level of the stack capable of holding one double word. Execution unit 32 has two sixteen-level FIFO stacks, each capable of holding one double word per level.
In addition, each execution unit has an associated command stack. Execution units 28 and 30 can hold up to 16 commands awaiting execution while execution unit 32 can hold up to 4 commands awaiting execution. It should be noted that the decision as to which execution unit received or is assigned a given instruction and its associated operand is determined by the central pipeline unit 12 by examining the operational code of each instruction. The particular method used in the preferred embodiment is a conventional table lookup technique. Input stacks 38 to 42 allow the central pipeline unit structure 12 to issue operands and associated operation codes to the execution units at a maximum rate of one per clock period, without waiting for the completion of the execution of preceding multiple execution cycle instructions, for example. Such an arrangement also allows exe-_' cution of instructions in the different execution units to be overlapped. Each instruction code is always executed in the order it is received from the central pipeline unit 12.
The system architecture of processor 10; i.e., having several execution units, requires that several copies of the major registers, for example the A and the Q, be kept. As processing proceeds, the valid copy of a particular register may be in any one of the execution units or in any of several different register banks within processor 10. Central pipeline unit structure 12 maintains a record of the currently valid copy for each register and recognizes when the execution of the next instruction requires transferring a copy of the contents of a register from one execution unit to another. However, maintaining a valid copy of the contents of a particular register is complicated by the length of pipeline 12, which is five instructions or clock periods deep. The ability to determine the contents of each addressable register immediately prior to the occurrence of a fault is a requirement for prompt recovery from a fault.
In any pipeline computer, processing of any one instruction is overlapped with the processing of several other instructions in different stages of execution. In addition, in CPU 10 several instructions may simultaneously be executed in different execution units. As a result, at any one time, the registers of pipeline 12 and of execution units 26 to 32 could contain register changes resulting from the processing and execution of several different instruction codes. When an instruction program fault, instruction processing error, or an interrupt occurs, collector 36 must be halted at the end of the last successfully completed instruction. All register changes as a result of the execution in program order of instructions prior to the fault, error, or interrupt should be completed and any program visible register change or changes to memory as a result of execution of later in program order instructions must be cancelled or deleted. Collector 36 provides a valid, current copy of each of the program addressable registers to facilitate fault and error recovery and for handling interrupts.
A record of the proper program order for all instructions in execution being processed by CPU 10 is maintained in instruction execution queue 34, which contains one entry for every instruction in process. Entries into the master safe store 54 and into store stack 56 are ordered so that they are unloaded in proper program order; i.e., the same order or sequence in which the instructions are stored into the instruction execution stack 34 by the central pipeline unit's distributor 24. The instruction execution queue words contain the operation code of the instruction and identify by means of a table lookup technique the execution results stack in which the result of that instruction when executed is, or will be, entered. The result of each instruction executed is then transferred from the appropriate results stack to master safe store 54 or to store stack 56 in program order. Thus, in collector 36, instructions are completed and the results of each are received and arranged in the proper or program order.
Collector 36 also performs the actual execution of all memory store instructions. Master safe store 54 contains a copy of all program visible registers so that it is a convenient place to obtain the contents of program visible registers which are to be written into memory. Handling store instructions in collector 36 with the data to be written into memory 22 coming from either master safe store 48 or the execution units' results stacks via store stack 56 maintains program order and avoids the necessity for the execution units 44 through 50 from being involved in store instructions. Thus, in this sense, collector 36 is another execution unit for processing store instructions. As a result, simple stores can be overlapped with the execution of other instructions taking two or more clock periods. The information stored in the master safe store 48 makes it relatively easy for the central processor unit 10 to retry hardware instructions where deemed necessary.

Claims

1. A central processor for a general purpose digital data processing system, characterised by:

cache means adapted to store instructions and operands;

a plurality of instruction execution units, each of which is adapted to execute a different set of the instructions;

instruction fetch means for fetching instructions from the cache means and for queuing instructions awaiting exeuction;

central unit means for obtaining instructions from the instruction fetch means, for decoding the instructions, preparing the address of an operand to be operated upon by the instruction, checking to determine if the addressed operand is stored in the cache means, accessing the addressed operand from the cache and dispatching the instruction and its operand to one of the execution units; and

collector means for receiving the results of the execution of each instruction from the execution units in program order and for writing into the cache means the results of the execution of instructions which are to be written into memory.

2. A central processor according to Claim 1, characterized in that the cache means includes operand cache means for storing operands and an instruction cache means for storing instructions.

3. A central processor according to Claim 2, characterized in that the collector means can write into the operand cache means.

4. A central processor according to any previous Claim, characterized in that the execution units include:

a central execution unit for executing basic computer operations;

a virtual memory and security manager unit for executing instructions relating to virtual memory and security;

a binary and arithmetic word for executing binary arithmetic and floating point instructions; and

a decimal/character execution unit for executing alphanumeric, decimal arithmetic, and bit string instructions.

5. A central processor unit according to Claim 4, characterized in that each of the virtual memory and security, binary and arithmetic, and decimal/character exeuction units has associated with it a respective input stack for receiving the operation codes and operands to be executed by the associated execution unit.

6. A central processor according to any previous Claim, characterized in that each execution unit has associated therewith a respective results stack unit in which the results of the execution of an instruction by the associated execution unit is stored in the order executed.