JP4654433B2 - Data processing apparatus, data processing program, and recording medium on which data processing program is recorded - Google Patents

Description

  The present invention relates to a data processing apparatus that performs a process of reading an instruction sequence and / or a value from a main storage unit and writing a result of an arithmetic process into the main storage unit.

  2. Description of the Related Art Conventionally, research and development relating to a technique for increasing the operation speed of a microprocessor such as a CPU (Central Processing Unit) has been actively conducted. Examples of the speed-up technology include pipeline, superscaler, out-of-order execution, and register renaming.

  Pipeline is a technique that decomposes instruction execution processing into several stages, and flows a plurality of instructions and performs simultaneous processing. Superscaler is a technology that prepares two or more instruction execution circuits and executes a plurality of instructions simultaneously in parallel. Out-of-order execution is a technique for ignoring the description order of instructions and searching for the first executable instruction among several consecutive instructions and performing a preceding process. Register renaming is a technique for increasing the probability that parallel processing is performed by increasing the number of general-purpose registers while maintaining compatibility of instructions in a conventional processor, for example, in a CISC (Complex Instruction Set Computer) type processor. .

  Thus, in order to increase the calculation speed in the microprocessor, it is important to execute instructions in parallel. However, most of the programs include a dependency relationship in which different instructions are executed depending on the result of a certain instruction, in other words, a branch. When such a branch is included, if processing is performed in advance by parallel processing, a situation occurs in which the content of the preceding processing is wasted depending on the result of the branch, and the calculation speed is increased. There is a problem that the effect of.

  Therefore, when there is a branch in the program, many studies have been made on a technique for reducing the probability that the preceding process is wasted by predicting the branch destination and improving the effect of parallel processing, so-called branch prediction.

  However, when speculative preceding processing is performed based on branch prediction, there are generally the following problems. The first problem is that the execution time of the preceding instruction sequence itself cannot be reduced because it is necessary to always verify the correctness of the prediction. As a second problem, since it is necessary to invalidate a series of predecessor operation results based on erroneous prediction, in order to increase the number of instructions that can be speculatively processed at once, a corresponding hardware cost is required. That is the point. As the third problem, the more the dependency between instructions, the more it becomes necessary to carry out speculative predecessor processing, and the verification validity verification process and the invalidation process based on erroneous prediction are extremely complicated. Is that it becomes.

  On the other hand, a technique called value reuse has also been proposed as a speed-up technique different from branch prediction. In this value reuse, input values and output values related to a part of the program are registered in the reuse table, and when the same part is executed again, the input values are registered in the reuse table. Is a technique of outputting a registered output value. The effects of this value reuse include the following. (1) If the input value matches the input value registered in the reuse table, there is no need to verify the execution result. (2) The hardware cost is determined only by the total number of input values and output values, and the length of the instruction sequence that can be omitted is not restricted. (3) The degree of dependency between instructions does not affect the complexity of the reuse mechanism. (4) Redundant load / store instructions can be reduced, and power consumption can be reduced accordingly.

  Non-Patent Document 1, which will be described later, shows a technique for reusing values for functions in a program. In this prior art, a load module is generally used in accordance with ABI (Application Binary Interface), and in particular, SPARC (Scalable Processor ARChitecture) ABI is used. Then, value reuse is realized by specifying input / output of a function in this ABI. That is, it is not necessary to embed a dedicated instruction by a compiler for value reuse, and application to an existing load module is possible.

  Also, by dynamically grasping the multiplex structure of functions, local registers in the function and local variables on the stack are excluded from input / output values in value reuse, thereby improving efficiency. For functions in particular, regardless of the complexity of the function, reuse and pre-execution are possible by registering a maximum of 6 register inputs, a maximum of 4 register outputs, and a minimum main memory value that does not include local variables. ing. This prior art will be described in detail below.

  First, for a single function, we will clarify what is input and what is output, and explain the mechanism required to perform one-level reuse. In a program, functions generally form multiple structures. FIG. 17A shows a structure in which the function A (Function-A) calls the function B (Function-B).

The band variable (Globals) can be an input / output (A _in / A _out ) of the function A and an input / output (B _in / B _out ) of the function B. The local variable (Locals-A) of the function A is not an input / output of the function A, but can be an input / output of B through a pointer. An argument (Args) from function A to function B can be an input to function B, and a return value (Ret.Val.) From function B to function A can be an output from function B. It is. The local variable (Locals-B) of the function B is not included in the input / output of the function A and the function B.

In order to reuse the function B without depending on the context, only the input / output B _in / B _out of the function B must be registered as the input / output when the function B is executed. Here, FIG. 17B shows a memory map in the main memory when executing the program structure shown in FIG. In this memory map, the only area that does not include B _in / B _out is Locals-B. Therefore, _{in order} to identify B _in / B _out , the boundary between Globals and Locals-B and the boundary between Locals-B and Locals-A must be determined, respectively. For the former, the OS (Operating System) generally determines the upper limit of the data size and stack size at the time of execution, and the boundary between Globals and Locals-B is determined based on the boundary (LIMIT) set by the OS. It can be confirmed. For the latter, the boundary between Locals-B and Locals-A can be determined by using the value of the stack pointer (SP in A) immediately before B is called.

Next, a method for identifying whether a given main memory address is a global variable or a local variable of which function will be described. It is assumed that the load module satisfies the following conditions specified in SPARC ABI. Note that% fp means a frame pointer, and% sp means a stack pointer.
(1) Of the areas above% sp,% sp + 0 to 63 are register save areas, and% sp + 68 to 91 are argument save areas, and none of them is function input / output.
(2) An implicit argument (Implicit Arg.) For returning a structure is stored in% sp + 64 to 67.
(3) An explicit argument (Explicit Arg.) Is placed in an area of registers% o0 to 5 and% sp + 92 or more.

First, in order to distinguish between a global variable and a local variable, generally, the OS determines the upper limit of the data size and stack size at the time of execution, and assumes the following matters.
(1) Global variables are placed in the area below LIMIT.
(2)% sp never falls below LIMIT, and the area from LIMIT to% sp is invalid.

  FIG. 18 shows an outline of arguments and frames in the memory map when the function A calls the function B while satisfying the above conditions. A method for distinguishing the local variable A and the local variable B will be described below with reference to FIG.

  In the figure, (a) shows a state in which A is being executed. Instructions (Instructions) and global variables (Global Vars.) Are stored in a thick frame part less than LIMIT, and valid values are stored above% sp. In% sp + 64, the head address of the structure is stored as an implicit argument when B returns the structure. The first 6 words of the explicit argument for B are stored in registers% o0 to 5 and the seventh and subsequent words are stored in% sp + 92 or more. When an operand% sp + 92 having a base register% sp appears, this area is the seventh word of the argument, that is, a local variable of B. On the other hand, if the operand% sp + 92 does not appear, this area is a local variable of A. Thus, in the state (a), the local variable of A and the B local variable can be distinguished by verifying the operand.

  On the other hand, (b) shows a state in which B is being executed. Arguments can be input, return values can be output, global variables and A local variables can be input / output. However, since B may accept a variable-length argument, it is generally impossible to determine whether the area of% fp + 92 or more is the local variable area of A or the local variable area of B.

  In order to distinguish local variables, first, the function call that detects the seventh word and the following of the argument at the time of (a) is excluded from the reuse target, and the function call that does not detect the seventh word and later is immediately before% sp + 92. Record the value of. In addition, since the appearance frequency of function calls using the seventh word and later is expected to be low, it is considered that the performance degradation due to the restriction that the function using the seventh word and later is excluded from reuse.

  From the above preparation, it can be seen that when the main memory reference address in (b) is greater than or equal to the previously recorded value of% sp + 92, it is a local variable of A, and if it is smaller, it is a local variable of B. At the time of execution of B, the global variable and the local variable of A are registered in the reuse table while excluding the local variable of B.

  At the time of reuse, since the local variable of B is excluded from input / output, the address of the local variable of B does not need to match. Therefore, any context can be reused as long as the input matches. However, for the global variable referenced by B and the local variable of A, both the address and data need to completely match the contents of the reuse table. That is, the point is how to cover the main memory addresses to be compared before executing B.

  The address of the global variable referred to by B or the local variable of A is originally based on an address constant generated in B or a pointer originating from the global variable / argument. Therefore, first, by selecting an entry in the reuse table whose arguments completely match, by referring to all the related main memory addresses and performing a matching comparison, it is possible to cover the main memory addresses that B should refer to. it can. The registered output (return value, global variable, and A local variable) can be reused only when all the inputs match.

  In order to realize function reuse, a function management table (RF) and an input / output record table (RB) are provided as reuse tables. A hardware configuration necessary for reusing one function is shown in FIG. To make a plurality of functions reusable, a plurality of sets of this configuration are prepared.

  In this table, V held in RF and RB is a flag indicating whether or not an entry is valid, and LRU (least recently used) indicates a hint for entry replacement. In addition to the above V and LRU, the RF holds the start address (Start) of the function and the main memory address (Read / Write) to be referred to. In addition to the above V and LRU, RB includes% sp (SP) immediately before the function call, argument (Args.) (V: valid entry, Val .: value), main memory value (Mask: Read / Write address) Holds valid byte, Value: value), and Return Values (V: valid entry, Val .: value).

  The return value is stored in% i0 to 1 (read as% o0 to 1 in the leaf function) or% f0 to 1, and the return value using% f2 to 3 (extended double precision floating point number) is not included in the target program. Assume that it does not exist. The read address is collectively managed by the RF, and the mask and value are managed by the RB, thereby enabling a configuration in which the contents of the read address and a plurality of entries of the RB are compared at once by a CAM (content-addressable memory).

  To reuse a single function, first, input / output information related to arguments, return values, global variables, and local variables of higher-level functions is registered in the reuse table while excluding local variables when the function is executed. . Here, the argument register preceded by reading is registered as the input / output of the function, and the writing to the return value register is registered as the output of the function. Other register references do not need to be registered. Similarly, in the main memory reference, an address preceded by reading is registered as input and writing as output.

  When the next function is called before returning from the function, or the input / output to be registered exceeds the capacity of the reuse table, the seventh word of the argument is detected, a system call or interrupt occurs in the middle, etc. If no disturbance occurs, the registered I / O table entry is validated when the return instruction is executed.

  Hereinafter, with reference to FIG. 19, before calling a function, (1) a function head address is searched, (2) an entry whose arguments completely match is selected, and (3) an associated main memory address, that is, All read addresses where at least one mask is valid are referred to, and (4) match comparison is performed. When all the inputs match, (5) the execution of the function can be omitted by writing back the registered output (return value, global variable, and A local variable).

  Here, as an example of the instruction interval, an example in which the instruction interval shown in FIG. 20 is executed by the configuration of RF and RB shown in FIG. 19 will be described. In the figure, PC indicates a PC value when the instruction section is started. That is, the head of the instruction section is 1000 addresses. FIG. 21 shows the input address and input data registered in the RB and the output address and output data in a simplified manner when the instruction section shown in FIG. 20 is executed. The actual registration status is shown.

  In the first line instruction (hereinafter simply referred to as the first instruction), the address constant A1 is set in the register R0. In the second instruction, 4-byte data (00110000) loaded from the main memory with the contents of the register R0 as an address is stored in the register R1. In this case, address A1, mask (FFFFFFFF) (in the mask, F indicates a valid byte, 0 indicates an invalid byte), and data (00110000) are registered as inputs in the first column on the Input side of the RB. , Register number R1, mask (FFFFFFFF), and data (00110000) are registered as outputs in the first column on the Output side of RB.

  In the third instruction, the address constant A2 is set in the register R0. In the fourth instruction, 1-byte data (02) loaded from the main memory having the contents of the register R0 as an address is stored in the register R2. In this case, the address A2, the mask (FF000000), and the data (02) are registered as inputs in the second column on the Input side of the RB. At this time, “−” indicating Don't Care is stored for the remaining 3 bytes of the address A2. Register number R2, mask (FFFFFFFF), and data (00000002) are registered as outputs in the second column on the Output side of RB.

  In the fifth instruction, 1-byte data (22) loaded from the address (A2 + R2) is stored in the register R2. Since the value of the address R2 is (02), the address (A2 + 02) and the data (22) are additionally registered in the second column on the Input side in the RB as inputs. At this time, registration is performed in the portion of the address (A2 + 02), and the portions corresponding to the addresses (A2 + 01) and (A2 + 03) remain “−” meaning Don't Care. That is, the mask corresponding to the address A2 is (FF00FF00). The register number R2, mask (FFFFFFFF), and data (00000022) are overwritten in the second column on the Output side of the RB as output.

  In the sixth instruction, the address constant A3 is set in the register R0. In the seventh instruction, 1-byte data (33) loaded from the main memory whose address is the contents of the register R0 is stored in the register R3. In this case, the address A3, the mask (00FF0000), and the data (33) are registered as inputs in the third column on the Input side in the RB. Register number R3, mask (FFFFFFFF), and data (00000033) are registered as outputs in the third column on the Output side of RB.

  In the eighth instruction, 1-byte data (44) loaded from the address (R1 + R2) is stored in the register R4. In this case, since the addresses R1 and R2 are the addresses of the registers overwritten inside the instruction section, the addresses R1 and R2 are not input to the instruction section. On the other hand, since the address A4 generated by the address (R1 + R2) is an input in the instruction section, the address A4, the mask (00FF0000), and the data (44) are registered as inputs in the fourth column on the Input side in the RB. Register number R4, mask (FFFFFFFF), and data (00000044) are registered as outputs in the fourth column on the Output side of RB.

  In the ninth instruction, the value is read from the register R5, and the result obtained by adding 1 to the read value is stored in the register R5 again. In this case, register R5, mask (FFFFFFFF), and data (00000100) are registered as inputs in the fifth column on the Input side of RB. Register number R5, mask (FFFFFFFF), and data (00000101) are registered as outputs in the fifth column on the Output side of RB.

As described above, the following processing is performed when reading from the memory / register during instruction execution.
(1) If the Output side in the RB is searched and the read address / register number is already registered, the address / register number ends without being registered on the Input side.
(2) If it is not on the Output side of the RB, the Input side of the RB is searched. If the read address / register number is already registered, the address / register number is not registered and the process ends.
(3) If there is no input side in the RB, an entry is newly added to the RB, and the address / register number and value are registered.

In addition, the following processing is performed when writing to the memory / register during instruction execution.
(1) The output side in the RB is searched, and if the read address / register number is already registered, the value is updated and the process ends.
(2) If it is not on the Output side in the RB, an address / register number and a value read by newly adding an entry are registered.

  Patent Document 1 described below discloses a configuration in which a plurality of processors are provided and parallel pre-execution is performed in the configuration in which the above reuse is performed. As a method of predicting input when this parallel pre-execution is performed, a method of performing stride prediction based on the difference between the last appearing argument and the two most recently appearing arguments is disclosed.

If the input prediction is performed as described above, it is possible to effectively reuse the input parameter based on the result predicted in advance when the above-described input parameter continues to change monotonously.
IPSJ Journal: High Performance Computing System, HPS5, pp.1-12, Sep. (2002), "High-speed technology using function value reuse and parallel pre-execution" (Yasuhiko Nakajima, Katsuya Ogata, Shingo Masanishi) Masahiro Goto, Junichiro Mori, Toshiaki Kitamura, Junji Tomita) (issued on September 15, 2002) JP 2004-258905 A (publication date September 16, 2004)

  FIG. 23 shows an example of the history registered on the input side of the RB when the command section shown in FIG. 20 is repeatedly executed. In this example, the instruction interval is executed every time Time changes from 1 to 4, and each time the instruction interval is executed, the value of the address A2 is (02), (03), (04), (05). Along with this, the values in the other input elements change.

  Moreover, diff shown between each log | history has shown the variation | change_quantity of the value of a corresponding input element. The above-described conventional input prediction is performed using this diff. FIG. 24 shows a prediction result by this conventional input prediction.

  For example, the contents of a monotonously changing address (corresponding to the address A2 in the above example) like a loop control variable can be accurately predicted. However, when an array element is included in the instruction section, the array element value generally does not always change monotonously even if the subscript of the array element changes monotonously. In the example shown in FIG. 23, since the value loaded from the address A2 corresponds to the subscript of the array element, and the main memory reference using this subscript as the address changes the address, the number of input elements registered as the history It will change. In such a situation, since the regularity of the change in the same column is lost, as shown in the column corresponding to the address A3 in FIG. 24, the predictive predictive value is extremely deteriorated.

  When performing input prediction, it is a waste of hardware resources to predict values related to addresses whose contents do not change. In addition, when there is no regularity in the change of the value, the prediction can only be made assuming that the difference is 0, but the prediction may be lowered by forcibly predicting. In the example shown in FIG. 24, the change in the mask position itself should be predicted for the address corresponding to A2 + 4, but it is difficult to predict the change in the mask position. In this case, it can be seen that it is a good idea to directly refer to the main memory value without prediction.

  All of the above problems are problems caused by uniformly handling all registered addresses.

  The present invention has been made in order to solve the above-mentioned problems, and its purpose is to read out a sequence of instructions and / or values from the main storage means, and to perform processing for writing the result of the arithmetic processing into the main storage means An object of the present invention is to provide a data processing device, a data processing program, and a recording medium on which the data processing program is recorded that realizes more effective pre-execution of an instruction interval by improving the prediction accuracy in the processing device. .

  In order to solve the above problems, a data processing apparatus according to the present invention is a data processing apparatus that performs processing for reading a command section from a main storage means and writing a result of arithmetic processing into the main storage means. First arithmetic means for performing an operation based on an instruction section read from the means; a register used when reading and writing to the main storage means by the first arithmetic means; and an input pattern as an execution result of a plurality of instruction sections And an input / output storage means for storing an output pattern, and when the first arithmetic means executes an instruction section, an input pattern of the instruction section and an input pattern stored in the input / output storage means Matches the input pattern, the output pattern stored in the input / output storage means is stored in the register and / or main memory. In addition to performing the reuse processing output to the means, when storing the execution result of the instruction section by the first computing means in the input / output storage means, prediction should be made among the input elements included in the input pattern Differentiating between input elements and input elements that do not need to be predicted, the discrimination information is registered in the input / output storage means, and stored in the input / output storage means based on the discrimination information Of the input elements, a prediction processing means for predicting a change in the value of the input element to be predicted, and a second operation for executing in advance the corresponding instruction section based on the input element predicted by the prediction processing means And a pre-execution result of the instruction section by the second calculation means is stored in the input / output storage means.

  In the above configuration, the input pattern and the output pattern as the execution result of the plurality of instruction sections are stored in the input / output storage means, and when the instruction section is executed, the input pattern of the instruction section and the input / output storage means are stored. The configuration is such that reuse is performed when the stored input pattern matches. And the future change of the input element memorize | stored in the input-output memory | storage means is estimated by a prediction process means, Based on this prediction result, a 2nd calculating means will perform the prior execution of an instruction area. Yes.

  Here, when the input element is simply predicted as in the prior art described above, there is a problem that the effect of the prior execution by the prediction becomes very low due to the low prediction accuracy. On the other hand, according to the above configuration, first of all, the input element included in the input pattern is distinguished from the input element that should be predicted and the input element that does not need to be predicted by the distinction processing means. The prediction processing unit performs prediction for the input element that is determined to be predicted by the distinction processing unit. Therefore, since the prediction accuracy can be improved, it is possible to realize more effective pre-execution of the instruction interval. By performing such pre-execution, when the same instruction sequence appears next and the same input as the predicted input value is made, the value stored in the instruction sequence storage means is reused. Is possible.

  In the data processing device according to the present invention, in the above configuration, the distinction processing unit is used as a stack pointer or a frame pointer for each address of the register used for input, and the address In the case where the write instruction for is a constant set instruction, a constant flag may be set as discrimination information for the corresponding address, and in the other cases, the constant flag may be reset for the corresponding address.

  According to the configuration described above, it is possible to set a constant flag at an address where the address is fixed and the value is predicted to change monotonically among the addresses of the registers used for input. Therefore, it is possible to improve the predictive predictive value by performing prediction for the input element based on the address of the register in which the constant flag is set.

  Further, in the data processing apparatus according to the present invention, in the above configuration, when the input processing unit newly stores the input element in the input / output storage unit, the discrimination processing unit performs the discrimination information for the input element address. The change flag may be reset to the corresponding address when a store instruction is executed for the corresponding address after the change flag is reset and stored in the input / output storage means.

  According to the above configuration, the change flag is reset for an address that is stored in the input / output storage means but is never written thereafter. Since the contents stored at such an address have not changed, it is not necessary to make a prediction for the address. That is, by providing the change flag as described above at the address of the input element, it is possible to perform prediction only for the address that needs to be predicted. Therefore, it is possible to effectively use hardware resources for prediction processing.

  Further, in the data processing apparatus according to the present invention, in the above configuration, when the input processing unit newly stores the input element in the input / output storage unit, the discrimination processing unit performs the discrimination information for the input element address. The history flag may be reset as described above, and when the load instruction for the address is executed, if the constant flag is set in the register address that generated the address, the history flag may be set for the address.

  According to the above configuration, when the load instruction is executed for the address of the input element stored in the input / output storage means, if the constant flag is set to the register address that generated the address, A history flag is set. Here, the register address in which the constant flag is set is an address where the address is fixed and the value is predicted to change monotonously as described above. Therefore, it is expected that the predictive predictive value by performing the prediction on the address generated based on such a register address is increased. That is, by providing the history flag as described above, it is possible to appropriately set the address to be predicted.

  As the history flag, a literal flag may be set for each address, or the history flag is realized in a format such as a mask indicating a byte position to be stored in a history among addresses consisting of a plurality of byte data. You may make it do.

  Further, in the data processing apparatus according to the present invention, in the above configuration, when the input processing unit newly stores the input element in the input / output storage unit, the discrimination processing unit performs the discrimination information for the input element address. And when the store instruction is executed for the corresponding address after being stored in the input / output storage means, the change flag is set for the corresponding address, and the prediction processing means Of the addresses of the input elements stored in the input / output storage means, the change of the input elements may be predicted with respect to the address where the change flag is set and the history flag is set.

  Here, as described above, the address for which the change flag is set is an address at which the effect of performing the prediction can be expected. In addition, as described above, the address where the history flag is set is an address that can be expected to have a high predictive predictive value. Therefore, according to the above configuration, prediction is performed only for addresses that are expected to have a high effect by performing prediction. Therefore, it is possible to effectively use hardware resources for prediction processing.

  In the data processing device according to the present invention, in the above configuration, the prediction processing unit is configured such that, among the input elements stored in the input / output storage unit, the change amount of the value in the history of the input element is zero. It is good also as a structure which estimates the change of the value of an input element only with respect to the input element which does not exist.

  According to the above configuration, the change in the value of the input element is predicted only for the input element whose value change in the history is not zero. Here, the input element whose value change amount in the history is 0 is an input element that is expected to have no change, and thus it is not necessary to perform prediction on the input element. That is, according to the above configuration, it is possible to perform prediction only for addresses that need to be predicted. Therefore, it is possible to effectively use hardware resources for prediction processing.

  As described above, the data processing apparatus according to the present invention predicts among the input elements included in the input pattern when storing the execution result of the instruction section by the first arithmetic unit in the input / output storage unit. The input element to be performed is distinguished from the input element that does not need to be predicted, and the distinction information is registered in the input / output storage means, and stored in the input / output storage means based on the distinction information A prediction processing means for predicting a change in the value of the input element to be predicted among the input elements that are to be predicted, and a corresponding instruction section in advance based on the input elements predicted by the prediction processing means And a second execution means, and the pre-execution result of the instruction section by the second operation means is stored in the input / output storage means.

  As a result, it is possible to improve the prediction accuracy, and it is possible to realize more effective pre-execution of the instruction interval. By performing such pre-execution, when the same instruction sequence appears next and the same input as the predicted input value is made, the value stored in the instruction sequence storage means is reused. There is an effect that becomes possible.

  One embodiment of the present invention will be described below with reference to FIGS.

(Configuration of data processing device)
FIG. 2 shows a schematic configuration of the data processing apparatus according to the present embodiment. As shown in the figure, the data processing apparatus includes an MSP (Main Stream Processor) 1A, an SSP (Shadow Stream Processor) 1B, an RF / RB (instruction sequence storage means) 2 as a reuse table, and a main memory (main The storage unit) is configured to read out program data stored in the main memory 3, perform various arithmetic processes, and perform a process of writing the arithmetic results into the main memory 3. In the configuration shown in the figure, the configuration includes one SSP 1B, but the configuration may include two or more.

  RF / RB2 is a memory means for storing data for reusing functions and loops in a program, and has a configuration including an RB registration processing section (discrimination processing means) 2A and a prediction processing section (prediction processing means) 2B. It has become. Details of the RF / RB 2 and details of the RB registration processing unit 2A and the prediction processing unit 2B will be described later.

  The main memory 3 is a memory as a work area of the MSP 1A and the SSP 1B, and is constituted by, for example, a RAM (Random Access Memory). For example, a program or data is read from an external storage means such as a hard disk to the main memory 3, and the MSP 1A and SSP 1B perform calculations based on the data read to the main memory 3.

  The MSP 1A includes an RW (reuse storage unit) 4A, an arithmetic unit (first arithmetic unit) 5A, a register 6A, and a Cache 7A. Similarly, the SSP 1B includes a RW (reuse storage unit) 4B, a computing unit (second computing unit) 5B, a register 6B, and a Cache / Local 7B.

  The RWs 4A and 4B are reusable windows, and hold RF and RB entries (described later) that are currently being executed and registered as a ring structure stack. The RW 4A and 4B are configured by a set of control lines that activate a specific entry in the RF / RB 2 as an actual hardware structure.

  The arithmetic units 5A and 5B perform arithmetic processing based on the data held in the registers 6A and 6B, and are called ALUs (arithmetic and logical units). The registers 6A and 6B are storage means for holding data for performing calculations by the calculators 5A and 5B. In this embodiment, it is assumed that the arithmetic units 5A and 5B and the registers 6A and 6B conform to the SPARC architecture. The Caches 7A and 7B function as cache memories between the main memory 3 and the MSP 1A and SSP 1B. In SSP1B, Cache7B includes Local7B as a local memory.

(Configuration of RF / RB)
FIG. 1 shows a reuse table realized by the RF / RB 2 in the present embodiment. As shown in the figure, the RF stores a plurality of entries. For each entry, V indicates whether the entry is valid, LRU indicates a hint for replacing the entry, and the start address of the function. , A read / write indicating a main memory address to be referred to, and an F / L for distinguishing between a function and a loop.

  The RB stores a plurality of entries corresponding to the entries stored in the RF. For each entry, V indicates whether the entry is valid, and indicates an entry replacement hint. SP indicating stack point% sp immediately before calling LRU, function or loop, argument (Args.) (V: valid entry, Val .: value), main memory value (C-FLAG: Read address change flag, P-Mask: Read address history mask, Mask: Valid byte of Read / Write address, Value: Value), Return Values (V: Valid entry, Val .: Value), Loop end address (End) Holds / not indicating the branching direction at the end of the loop, and registers and condition codes (Regs., CC) other than arguments and return values. The RB also holds a memory area for storing a constant flag (Const-FLAG) corresponding to one or more register addresses. Details of the constant flag (Const-FLAG) will be described later.

  Each item in the RF and RB will be described in more detail. The above V indicates whether or not the entry is valid as described above. Specifically, it is “0” when not registered, “2” when registered, and registered. In this case, the value “1” is stored. For example, when securing RF or RB, if there is an unregistered entry (V = 0), this is used, and if there is no unregistered entry, LRU is the smallest among registered entries (V = 1). Select one and overwrite it. The entry being registered (V = 2) is in use and cannot be overwritten.

  The LRU indicates the number of “1” in the shift register that is shifted to the right at regular time intervals. In the case of RF, this shift register is configured such that “1” is written at the left end when registration for reuse is performed or the reuse is attempted for the corresponding entry. Therefore, if the corresponding entry is frequently used, the LRU value is large. If the entry is not used for a certain period, the LRU value is 0. On the other hand, in the case of RB, “1” is written in the shift register when the corresponding entry is reused. Therefore, if the corresponding entry is frequently used, the LRU value is large. If the entry is not used for a certain period, the LRU value is 0.

  The main memory value Mask in the RB will be described. In general, management is possible by managing addresses and data one byte at a time, but in practice, cache management can be performed at higher speed by managing data in units of 4 bytes. Therefore, in RF, the main memory address is stored as a multiple of four. On the other hand, if the management unit is 4 bytes, it is necessary to indicate which of the 4 bytes is valid in order to be able to support loading only 1 byte. That is, Mask is 4-bit data indicating which of the 4 bytes is valid. For example, if the value of E8 is loaded from address C001 and the value is E8, address C000 is registered in RF, “0100” is registered in Mask of RB, and “00E80000” is registered in Value. Become. The details of the change flag (C-FLAG) and history mask (P-Mask) in the Read address will be described later.

  The registers and condition codes (Regs., CC) other than the above arguments and return values will be described. In this embodiment, among the SPARC architecture registers, general-purpose registers% g0-7,% o0-7,% l0-7,% i0-7, floating point register% f0-31, condition code register ICC, and floating point condition code The register FCC is used (details will be described later). Of these, the input of the leaf function is general-purpose register% o0-5, the output is general-purpose register% o0-1, the input of non-leaf function is general-purpose register% i0-5, and the output is general-purpose register% i0-1. The input is registered in arg [0-5], and the output is registered in rti [0-1]. According to the SPARC-ABI rules, the registers other than these do not serve as input / output of functions, so the argument (Args.) In RB is sufficient for functions.

  On the other hand, according to the SPARC-ABI rules, the type of register used cannot be specified for loop input / output. Therefore, in order to specify loop input / output, all types of registers must be registered in the RB. There is. Therefore,% g0-7,% o0-7,% 10-7,% i0-7,% f0-31, ICC, FCC are registered in Regs., CC in RB.

  As described above, in RF / RB2, the read address is collectively managed by RF, and the mask and value are managed by RB. As a result, a configuration is possible in which the contents of the Read address and a plurality of RB entries are compared at once by CAM (content-addressable memory). This will be described in more detail below.

  Generally, when an address is given, a memory that can refer to a value stored at the address is a memory called a RAM. On the other hand, the CAM is a memory called an associative memory, and operates so that when a content to be searched is given, a signal corresponding to the entry is turned ON. Normally, CAM is used as a set with RAM.

  Here, the cooperative operation between the CAM and the RAM will be described with a specific example. "5, 5, 5, 5, 5", "1, 3, 1, 1, 1", "1, 3, 3, 5, 2", "6, 6, 6, 6, 6" The data strings “5, 5”, “1, 1”, “1, 2”, “6, 6” are stored in the RAM corresponding to the data strings in the CAM. Suppose that it is registered. Here, when “1, 3, 3, 5, 2” is input to the CAM as the data string to be searched, the matching entry is turned ON, and the corresponding data “1, 2” registered in the RAM is output. Will be. The RB is realized by the same configuration and operation as this specific example.

(Outline of reuse processing)
Next, the outline of the reuse process will be described for each case of the function and the loop.

  First, the case of a function will be described. When the next function is called before returning from the function, or the input / output to be registered exceeds the capacity of the reuse table, the seventh word of the argument is detected, a system call or interrupt occurs in the middle, etc. If no disturbance occurs, the registered I / O table entry is validated when the return instruction is executed.

  Hereinafter, description will be made with reference to FIG. 1. Before calling a function, (1) a search is made as to whether the start address of the function in the entry registered in the RF matches the start address of the corresponding function. If there is a match, (2) an entry in which the argument in the entry related to the function registered in the RB completely matches the argument of the function to be called is selected. Then, (3) the related main memory address, that is, at least one read address in which at least one mask is valid is referred to from RF, and (4) the content is registered with RB. When all the inputs match, (5) by omitting the execution of the function by writing back the output (return value, global variable, and A local variable) registered in the RB to the main memory 3, that is, the function Can be reused.

  Next, the case of a loop will be described. If loop I / O registration is not canceled, such as when the function returns before the loop is completed or the above disturbance occurs, it will be registered when the backward branch instruction corresponding to the registered loop is detected. Validate the input / output table entry in the middle and complete the registration of the loop.

  Further, when the backward branch instruction is established, it is determined whether or not the next loop can be reused. That is, referring to FIG. 1, before branching backward, (1) a search is made as to whether or not there is a match with the start address of the corresponding loop start address in the entry registered in the RF. If there is a match, (2) an entry in which the register input value related to the corresponding loop registered in the RB completely matches the register input value of the calling loop is selected. Then, (3) all related main memory addresses are referred to from RF, and (4) a comparison with the contents registered in RB is performed. When all inputs match, (5) loop execution is omitted by writing back the output (register and main memory output value) registered in RB back to main memory 3, that is, reusing the loop. be able to.

  When reused, the same processing is repeated for the next loop based on the branch direction registered in the RB. On the other hand, if the next loop is not reusable, the next loop is executed normally and registration to RF and RB is started.

(Processing flow during execution of instruction section)
Next, a specific processing flow when an instruction is decoded will be described. In the following, the flow of processing is explained for each case where the result of decoding is a function call instruction, a function return instruction, a backward branch is established, a backward branch is not established, and other instructions. To do.

(If it is a function call instruction)
Processing when the instruction is decoded as a result of function decoding will be described below with reference to the flowchart shown in FIG. First, in step 1 (hereinafter referred to as S1), it is determined whether or not the seventh word of the argument has been detected. If YES in S1, that is, if it is determined that the seventh word of the argument has been detected, all registered RB entries registered in the RW are invalidated, the process proceeds to S6, and the program counter is moved to the head of the function. Proceed and finish the process.

  On the other hand, if NO in S1, that is, if it is determined that the seventh word of the argument has not been detected, it is searched whether or not the function call and input value are registered in RF and RB (S2). If YES in S2, that is, if it is determined that the function call and the input value are registered in RF and RB, the process proceeds to step S7 described later.

  If NO in S2, that is, if it is determined that the function call and input value are not registered in RF and RB, an attempt is made to secure an RF entry and RB entry for the function, and (1) an existing RF entry (2) There is an RF entry that can be used in addition to an RF entry that cannot be driven out during registration work, or (3) an RB that can be used in addition to an RB entry that cannot be driven out during registration work It is determined whether there is an entry (S3).

  If NO in S3, that is, if it is determined that there is no usable RF / RB entry, registration is not started, all RBs registered in RW are invalidated (S5), and RW is emptied. On the other hand, if YES in S3, that is, if it is determined that there is an available RF / RB entry, an RF entry and an RB entry for the function are secured and registered in the RW (S4). Here, when the RW entries registered in the RW overflow when registered in the RW, the oldest RW entry is deleted and the corresponding RB is invalidated. After S3 or S4 is performed, the program counter is advanced to the beginning of the function (S6), and the process is terminated.

  On the other hand, if YES in S2, that is, if it is determined that the function call and the input value are registered in RF and RB, the function is reusable. That is, the output value is obtained from the RB, and the output value is written to the register and the main memory 3 (S7). Then, it is determined whether or not the function / loop being registered is registered in the RW (S8). If the function / loop is being registered, a necessary one of the contents of the RB entry of the function that has been reused is determined as the RW. (S9). Here, registration is performed in order from the TOP of the RW, and when the RB overflows in the middle, the RB up to the BOTTOM of the RW is invalidated and deleted from the RW. Thereafter, the program counter is advanced to the next instruction (S10), and the process is terminated.

(If it is a function return instruction)
Processing when the instruction is decoded as a result of function decoding will be described below with reference to the flowchart shown in FIG. In S11, it is determined in order from TOP of RW, whether or not RB related to the loop is detected before RF / RB corresponding to the function is detected (S12). If an RB related to the loop is detected (YES in S12), all the corresponding RBs are invalidated and deleted from the RW (S13).

  On the other hand, it is determined whether or not RF / RB corresponding to the function is detected during the RW search (S14). If an RF / RB corresponding to the function is detected (YES in S14), the corresponding RB entry is validated and deleted from the RW (S15).

  Thereafter, a return instruction is executed (S16), and the process is terminated.

(When backward branch is established)
The processing when the backward branch is established as a result of decoding the instruction will be described below with reference to the flowchart shown in FIG. First, it is determined in turn from TOP of RW whether or not RB corresponding to the function is detected (S21). If YES in S21, that is, if an RB corresponding to the function is detected, the process proceeds to step S24 described later.

  On the other hand, if NO in S21, that is, if the RB corresponding to the function is not detected, it is next determined whether or not the address of the backward branch instruction itself matches the loop end address in the RB (S22). ). If NO in S22, that is, if it is determined that the address of the backward branch instruction itself does not match the loop end address in the RB, the process proceeds to step S24 described later.

  If YES in S22, that is, if it is determined that the address of the backward branch instruction itself matches the loop end address in the RB, all RBs from the RW TOP to the front of the RB are invalidated (S23). delete. Also, the RB entry is validated and taken = 1 is deleted from the RW.

  Next, in S24, it is determined whether or not the start address and input value of the next loop are registered in RF and RB. If YES in S24, that is, if the start address and input value of the next loop are registered in RF and RB, the process proceeds to step S30 described later.

  On the other hand, if NO in S24, that is, if the start address and input value of the next loop are not registered in RF and RB, an attempt is made to secure the RF entry and RB entry for the next loop, and (1) There are RF entries, (2) There are RF entries that can be used in addition to RF entries that cannot be driven out during registration work, or (3) Can be used in addition to RB entries that cannot be driven out during registration work It is determined whether there is an RB entry (S25).

  If NO in S25, that is, if it is determined that there is no usable RF / RB entry, all the RBs registered in the RW are invalidated without starting the registration (S26), and the RW is emptied. . Thereafter, in S29, the program counter is advanced to the conditional branch destination, and the process ends.

  On the other hand, if YES in S25, that is, if it is determined that there is an available RF / RB entry, the available RF / RB entry is secured and the secured RF / RB is registered in the RW (S27). . Also, the loop end address (the address of the backward branch instruction itself) is registered in RB. Here, if the RW overflows when registering to the RW, the oldest RW entry is deleted (S28), and the corresponding RB is invalidated. Thereafter, in S29, the program counter is advanced to the conditional branch destination, and the process ends.

  On the other hand, if YES in S24 described above, the next loop is reusable, so an output value is obtained from RB and this value is written to the register and main memory 3 (S30). Here, it is determined whether or not the function / loop being registered is registered in the RW (S31). If registered, the necessary contents of the RB entry of the loop that has been reused are stored in the RW. It adds to the registered entry (S32). At this time, if the RB is registered in order from the TOP of the RW, and the RB overflows in the middle, the RB up to the BOTTOM of the RW is invalidated and deleted from the RW.

  After that, the program counter is not at the beginning of the next loop, but according to the value of take in the RB, the self-instruction when take = 1, and the loop end address stored in RB when take = 0 Proceed to the next. Thereafter, the process ends.

(If backward branch is not established)
The processing when the backward branch is not established as a result of decoding the instruction will be described below with reference to the flowchart shown in FIG. First, the search is performed in order from the TOP of the RW (S41), and it is determined whether or not the RB corresponding to the function has been detected (S42). If YES in S42, that is, if it is determined that an RB corresponding to the function has been detected, the program counter is advanced to the next instruction in S46, and the process ends.

  If NO in S42, that is, if it is determined that the RB corresponding to the function has not been detected, it is determined whether or not the address of the backward branch instruction itself matches the loop end address in the RB (S43). If NO in S43, that is, if it is determined that the RF / RB corresponding to the backward branch instruction has not been detected, the program counter is advanced to the next instruction in S46, and the process ends.

  On the other hand, if YES in S43, that is, if it is determined that the RF / RB corresponding to the backward branch instruction is detected, all RBs from the RW TOP to the front of the RB are invalidated (S44) and deleted from the RW. . Also, the RB entry is validated and taken = 0 is set and deleted from the RW (S45). Thereafter, the program counter is advanced to the next instruction in S46, and the process is terminated.

(In case of other instructions)
Next, a description will be given of the case where the instruction is decoded and other instructions than the above. In the case of other instructions, the register R / W and the main memory R / W are executed. At this time, if the RW is not empty, the register R / W and the main memory R / W are registered to the RB registered in the RW by the following procedure. In the following, (1) general-purpose register READ, (2) general-purpose register WRITE, (3) floating-point register READ, (4) floating-point register WRITE, (5) condition code register ICC-READ (6) Condition code register ICC-WRITE, (7) Floating point condition code register FCC-READ, (8) Floating point condition code register FCC-WRITE, (9) Main memory READ The case of (10) main memory WRITE will be described respectively.

(1) In the case of the general-purpose register READ First, the RW is sequentially traced from TOP to BOTTOM. (1-1) When the RB is a leaf function and% o0-6, or when the RB is a non-leaf function and% i0-6, arg [0-5]. If V = 0, arg Change [0-5] .V = 1 and record the read data in arg [0-5] .Val. Thereafter, RW is further traced, and when the RB is a function, the process is terminated. On the other hand, when the RB is not a function (is a loop), if arg [0-5] .V = 0, it is changed to arg [0-5] .V = 1 and arg [0-5]. The read data is recorded in Val, and the process ends.

  On the other hand, (1-2) When the RB is a loop, (a) If grr [0-7] .V = 0 at% g0-7, change to grr [0-7] .V = 1, Record the read data in grr [0-7] .Val and end the process. (B) If arg [0-7] .V = 0 at% o0-7, change to arg [0-7] .V = 1 and record the read data in arg [0-7] .Val The process is terminated. (C) If lrr [0-7] .V = 0 at% l0-7, change to lrr [0-7] .V = 1 and record the read data in lrr [0-7] .Val The process is terminated. (D) If% i0-7 and irr [0-7] .V = 0, change to irr [0-7] .V = 1 and record the read data in irr [0-7] .Val. To the next RW entry.

(2) In the case of the general-purpose register WRITE First, the RW is sequentially traced from TOP to BOTTOM. (2-1) When the RB is a leaf function and% o0-5, or when the RB is a non-leaf function and% i0-5, if arg [0-5] .V = 0, then Change to arg [0-5] .V = 2 to indicate that reading is not input. Further,% o0-1 /% i0-1 is changed to rti [0-1] .V = 1, and write data is recorded in rti [0-1] .Val. Thereafter, RW is further traced, and when the RB is a function, the process is terminated. On the other hand, when the RB is not a function (a loop), if arg [0-1] .V = 0, arg [0-1] .V is used to indicate that the subsequent reading is not an input. = 2, rti [0-1] .V = 1, write data is recorded in rti [0-1] .Val, and the process ends.

  On the other hand, (2-2) When the RB is a loop, (a) If grr [0-7] .V = 0 at% g0-7, change to grr [0-7] .V = 2, Record the write data in grr [0-7] .Val and finish the process. (B) If arg [0-7] .V = 0 at% o0-7, change to arg [0-7] .V = 2 and record the write data in arg [0-7] .Val The process is terminated. (C) If lrr [0-7] .V = 0 at% l0-7, change to lrr [0-7] .V = 2 and record the write data in lrr [0-7] .Val The process is terminated. (D) If% i0-7 and irr [0-7] .V = 0, change to irr [0-7] .V = 2 and record the write data in irr [0-7] .Val. To the next RW entry.

(3) Floating-point register READ First, the RW is sequentially traced from TOP to BOTTOM. (3-1) If the RB is a function, the process ends without doing anything. On the other hand, (3-2) When the RB is a loop, if frr [0-31] .V = 0, it is changed to frr [0-31] .V = 1 and frr [0-31] .Val The read data is recorded in, and the process ends.

(4) In the case of the floating-point register WRITE First, the RW is sequentially traced from TOP to BOTTOM. (4-1) If the RB is a function and% f0-1, then rtf [0-1] .V = 1 is changed and write data is recorded in rtf [0-1] .Val. Further follow RW and if frr [0-1] .V = 0, then change to frr [0-1] .V = 2 to indicate that the subsequent read is not an input, and rtf [0- 1] .V = 1, write data is recorded in rtf [0-1] .Val, and the process ends.

  On the other hand, (4-2) When the RB is a loop, if frr [0-31] .V = 0, it is changed to frr [0-31] .V = 2 and frw [0-31] .V Change to = 1, write data to frw [0-7] .Val, and finish the process.

(5) In the case of the condition code register ICC-READ First, the RW is sequentially traced from TOP to BOTTOM. (5-1) If the RB is a function, the process ends without doing anything. On the other hand, (5-2) When the RB is a loop, if icr.V = 0, it is changed to icr.V = 1, the read data is recorded in icr.Val, and the process is terminated.

(6) In the case of the condition code register ICC-WRITE First, the RW is sequentially traced from TOP to BOTTOM. (6-1) If the RB is a function, the process ends without doing anything. On the other hand, (6-2) If the RB is a loop, if icr.V = 0, change to icr.V = 2, icw.V = 1, record the write data in icw.Val, and finish.

(7) In the case of the floating point condition code register FCC-READ First, the RW is sequentially traced from TOP to BOTTOM. (7-1) If the RB is a function, the process ends without doing anything. On the other hand, (7-2) When the RB is a loop, if fcr.V = 0, the data is changed to fcr.V = 1, read data is recorded in fcr.Val, and the process is terminated.

(8) In the case of the condition code register ICC-WRITE First, the RW is sequentially traced from TOP to BOTTOM. (8-1) If the RB is a function, the process is terminated without doing anything. On the other hand, (8-2) When the RB is a loop, if fcr.V = 0, change to fcr.V = 2 and ffw.V = 1, record the write data in fcw.Val, and finish.

(9) Case of Main Memory READ First, the RW is sequentially traced from TOP to BOTTOM. If the RB has been registered as WRITE data, the value is used. On the other hand, when the data has been registered in the RB as READ data instead of the above case, the value is used. Further, if it is not registered in any of them, it is read from the main memory 3 via the cache.

  After that, the RW is followed again from the TOP to the BOTTOM. (A) When the address is sp + 64 registered in the RB, since the structure pointer is read, if arg0.V = 0, the address is changed to arg0.V = 1 and arg0.Val The read data is recorded in (B) Not in the case of (a) above, if the address is not less than LIMIT and less than sp + 92, it is a registration unnecessary area, so nothing is done. (C) If it is not the case of (b) above, it is checked whether or not it has been registered as WRITE data. If so, it is a READ after being overwritten, so registration is unnecessary and nothing is done. (D) If it is not (c) above, it is checked whether or not it has been registered as READ data. If so, it is already registered and no registration is required and nothing is done. (E) If it is not (d) above, registration as READ data is required, so a main memory READ address is secured in the RF and registered as READ data. If the main memory address cannot be secured in the RF, registration is impossible, and all RB entries corresponding to the RW entry to BOTTOM are invalidated.

(10) In case of main memory WRITE First, data is written in the main memory 3 via the cache. If the base register is 14 (% sp) and the offset is 92 or more, the fact that the seventh word of the argument has been detected is stored.

  Then, the RW is traced from the TOP to the BOTTOM. (A) When the address is sp + 64 registered in the RB, since the structure pointer is read, if arg0.V = 0, the address is changed to arg0.V = 2. (B) Not in the case of (a) above, but if the address is not less than LIMIT and less than sp + 92, it is a registration unnecessary area, so nothing is done. (C) If not in the case of (b) above, it is checked whether or not it has been registered as WRITE data. If so, the address has already been registered, so the contents are updated to new WRITE data. (D) If not (c) above, registration as WRITE data is required, so a main memory WRITE address is secured in the RF and registered as WRITE data. If the main memory address cannot be secured in the RF, registration is impossible, and all RB entries corresponding to the RW entry to BOTTOM are invalidated.

(Multiple reuse including loops)
When the reuse mechanism as described above is used at one level, in the example shown in FIG. 17A, the function B as the leaf function, the loop C inside the function B, etc. are reused. It becomes possible. On the other hand, multiple reuse is a mechanism for performing registration so that all instruction sections including functions and loops included in the function can be reused by executing a function once. For example, in the above example, according to multiple reuse, all the instruction sections of A, B, and C that are nested can be reused by executing the function A once. The function expansion required for realizing multiple reuse will be described below.

  FIG. 7 shows a conceptual structure of function A and function D as an example. In the example shown in the figure, a loop B exists inside the function A, a loop C exists inside the loop B, and the function D is called in the loop C. A loop E exists inside the function D, and a loop F exists inside the loop E.

  In FIG. 8, in the nested structure of the functions A and D and loops B, C, E, and F shown in FIG. 7, the register input / output (thick frame cell region) of the inner structure becomes the register input / output of the outer structure. The influence range (arrow) is shown. For example,% i0 to 5 referred to as an input in the loop F is also an input to the loop E and the function D, and further, an input to the loop C and the loop B that called the function D (but replaced with% o0 to 5). It is also. On the other hand, for function A,% o0 to 5 correspond to local variables, so% i0 to 5 (% o0 to 5) are not register inputs for function A. That is, the influence range of% i0 to 5 (% o0 to 5) is up to loop B. From another point of view, if% i0-5 is referenced inside function D,% o0-5 is input to loop B even if loop B does not directly reference% o0-5. Must be registered as a value. The same applies to% i0-1 output in the loop F.

  Since the floating point register is not included in the register window, the output% f0 to 1 is output of all layers including the function A. On the other hand, other register inputs and outputs have no effect beyond functions. That is, input / output in the loop F, that is,% i6-7,% g, l, o,% f0-31,% icc,% fcc as register inputs, and% I2-7,% g as register outputs , l, o,% f2 to 31,% icc,% fcc range up to loop E. As for the input / output to / from the main memory 3, the influence range can be specified by applying the above-described method of comparison with% sp (SP) immediately before the function call to all nested layers.

  From the above, in order to realize multiple reuse, a mechanism for associating the aforementioned RF and RB with a function or a loop nesting structure is necessary. As shown in FIG. 9, by having a reuse window (RW), the RF and RB entries (shown as A, B, and C in the figure) that are currently being executed and registered are maintained as a stack structure. To do. During execution of a function or loop, registers and main memory references are registered for all entries registered in the RW based on the method described so far.

  At this time, if it is determined that a certain entry cannot be reused by (1) exceeding the number of items that can be registered, (2) detecting the seventh word of the argument, and (3) detecting a system call. , The RB corresponding to the entry and the upper RB can be identified and registration can be stopped.

  Although the depth of RW is limited, if a function or loop is detected exceeding the multiplicity that can be registered at one time, registration is stopped sequentially from the outer instruction section, and the inner instruction section is registered. By adding to the object, it is possible to follow the dynamic change of the nesting relationship. When a reusable instruction section (eg, D) is encountered during execution and registration (eg, A), the RW depth is increased by adding the registered input / output to the entry being registered as it is. Multiple reuse of A exceeding A is also possible.

(Parallel pre-execution)
In the multiple reuse of functions and loops as described above, there is no effect if the interval at which the same parameter appears is longer than the lifetime of the RB entry or if the parameter continues to change monotonically. That is, when the same parameter appears longer than the lifetime of the RB entry, even when a certain function or loop is registered in the RB, the same parameter appears next for the registered function or loop. The function or loop has already disappeared from the RB entry and cannot be reused. In addition, when the parameter continues to change monotonously, even if the corresponding function or loop is registered in the RB, the parameter cannot be reused because the parameter is different.

  On the other hand, by providing a plurality of SSP1Bs as processors that enable the RB entry by pre-execution of the instruction section separately from the MSP1A as a processor that performs multiple reuse, it is possible to further increase the speed.

  The hardware configuration for performing the parallel pre-execution mechanism is as shown in FIG. As shown in the figure, the RWs 4A and 4B, the arithmetic units 5A and 5B, the registers 6A and 6B, and the caches 7A and 7B are provided independently for each processor, while the RF / RB 2 and the main memory 3 are provided. All processors are shared. In the figure, the broken lines indicate paths in which MSP 1A and SSP 1B register input / output to / from RF / RB2.

  Here, problems in realizing parallel pre-execution include (1) how to maintain main memory consistency, and (2) how to predict input. Below, the solution method with respect to these subjects is demonstrated.

(Solutions to main memory consistency issues)
First, the above problem (1) how to maintain main memory consistency will be described. In particular, when an instruction interval is executed based on the predicted input parameter, the value written to the main memory 3 differs between the MSP 1A and the SSP 1B. In order to solve this, as shown in FIG. 2, the SSP 1B uses the local memory provided for each SSP 1B for RF / RB2 for the main memory reference to be registered in the RB and for other local references. The local 7B is used, and writing to the cache 7B and the main memory 3 is unnecessary. When the MSP 1A writes to the main memory 3, the corresponding SSP 1B cache line is invalidated.

  Specifically, the address and value are registered in the RB in the same manner as the MSP 1A with reference to the main memory 3 for the address preceded by the reading among the registration targets in the RB. Thereafter, by referring to the RB instead of the main memory 3, it is possible to avoid inconsistency due to overwriting from another processor. As for local reference, the fact that reading precedes corresponds to using a variable without initializing it, and the value may be indefinite, so it is not necessary to refer to the main memory 3.

  Note that the capacity of the Local 7B as a local memory is finite, and if the execution cannot be continued, such as when the size of the function frame exceeds the capacity of the Local 7B, the pre-execution is aborted. Further, since the result of the pre-execution is not written to the main memory 3, the next pre-execution cannot be performed using the pre-execution result.

(Prediction mechanism)
Next, the problem (2) how to predict the input will be described. In advance execution, it is necessary to predict a future input based on the usage history of the RB and pass it to the SSP 1B. For this purpose, the RF / RB 2 is provided with a prediction processing unit 2B. The prediction processing unit 2B is configured by a small processor provided for each entry of RF, and obtains an input predicted value independently of the MSP 1A and SSP 1B.

  As described above, in the conventional input prediction, since all addresses registered on the input side in the RB are uniformly treated, the prediction accuracy is lowered. In order to solve this problem, we distinguish between addresses that are likely to be predicted and addresses that are likely to be unpredictable, and predict only the minimum necessary addresses by paying attention to changes in values. It is necessary to target.

  An address that can be expected to be predicted is an address whose address is fixed and whose value changes monotonously. Such addresses include a band variable referred to by a label and a local variable (an intra-frame variable) referred to using a stack pointer or a frame pointer as a base register.

  In order to identify these addresses, a constant flag (Const-FLAG) is provided in a register referred to by address calculation at the time of execution of a load instruction. It is assumed that constant flags are unconditionally set for registers used as stack pointers and frame pointers. For other registers, the constant flag (Const-FLAG) is set when an instruction to set a constant is executed.

  Next, among the addresses that have been referred to in the past, it is guaranteed that the contents have not changed, and there is no need to predict such addresses. Become. Therefore, in order to distinguish such addresses, a change flag (C-FLAG) indicating that writing has been performed is provided. When an address as an input element is newly recorded in the RF / RB, the change flag (C-FLAG) corresponding to the address is reset, and when a store instruction is executed for the address after registration, the change flag ( C-FLAG) is set.

  In addition, a history mask (P-Mask) indicating whether or not an address as an input element is a history storage target is provided. When an address as an input element is newly recorded in the RF / RB, a history mask (P-Mask) (history flag) corresponding to the address is reset. If the constant flag (Const-FLAG) corresponding to the register that generated the address is set when the load instruction is executed, the byte position to be loaded is set in the history mask (P-Mask). Is done.

  The control of the setting of the constant flag (Const-FLAG), the change flag (C-FLAG), and the history mask (P-Mask) is performed by the RB registration processing unit 2A provided in the RF / RB2. This RB registration processing unit 2A is configured by a small processor, and by making the above determination, the constant flag (Const-FLAG), the change flag (C-FLAG), and the history mask (P-Mask) are set. Do.

(Execution example of instruction section)
Here, as an example of the instruction interval, an example in which the instruction interval shown in FIG. 20 is executed by the configuration of RF and RB shown in FIG. 1 will be described. In the figure, PC indicates a PC value when the instruction section is started. That is, the head of the instruction section is 1000 addresses. FIG. 10 shows an actual registration status in the RB when the command section shown in FIG. 20 is executed.

  In the first instruction, the address constant A1 is set in the register R0. Since this instruction is an instruction for setting a constant, a constant flag (Const-FLAG) corresponding to the register R0 is set.

  In the second instruction, 4-byte data (00110000) loaded from the main memory 3 with the contents of the register R0 as an address is stored in the register R1. In this case, address A1, mask (FFFFFFFF), and data (00110000) are registered as inputs in the first column on the Input side in RB, and register number R1, mask (FFFFFFFF), and data (00110000) are output as RB in RB. Registered in the first column on the Output side.

  Since the constant flag (Const-FLAG) corresponding to the register R0 used as the address is set, the history mask (P-Mask) corresponding to the address A1 is set. Here, since the target data is 4-byte data of (00110000), (FFFFFFFF) is set in the history mask (P-Mask) corresponding to the address A1 corresponding to this. Since the constant is not set in the register R1, the constant flag (Const-FLAG) corresponding to the register R1 is reset.

  In the third instruction, the address constant A2 is set in the register R0. Since this instruction is an instruction for setting a constant, a constant flag (Const-FLAG) corresponding to the register R0 is set.

  In the fourth instruction, 1-byte data (02) loaded from the main memory 3 with the contents of the register R0 as an address is stored in the register R2. In this case, the address A2, the mask (FF000000), and the data (02) are registered as inputs in the second column on the Input side of the RB. At this time, “−” indicating Don't Care is stored for the remaining 3 bytes of the address A2. Register number R2, mask (FFFFFFFF), and data (00000002) are registered as outputs in the second column on the Output side of RB.

  Further, since the constant flag (Const-FLAG) corresponding to the register R0 used as the address is set, the history mask (P-Mask) corresponding to the address A2 is set. Here, since the target data is 1-byte data (02), (FF000000) is set in the history mask (P-Mask) corresponding to the address A2 corresponding to this. Since the constant is not set in the register R2, the constant flag (Const-FLAG) corresponding to the register R2 is reset.

  In the fifth instruction, 1-byte data (22) loaded from the address (A2 + R2) is stored in the register R2. Since the value of the address R2 is (02), the address (A2 + 02) and the data (22) are additionally registered in the second column on the Input side in the RB as inputs. At this time, registration is performed in the portion of the address (A2 + 02), and the portions corresponding to the addresses (A2 + 01) and (A2 + 03) remain “−” meaning Don't Care. That is, the mask corresponding to the address A2 is (FF00FF00). The register number R2, mask (FFFFFFFF), and data (00000022) are overwritten in the second column on the Output side of the RB as output.

  Since the constant flag (Const-FLAG) corresponding to the register R2 used as the address is reset, the history mask (P-Mask) corresponding to the address (A2 + 02) is not set. That is, the history mask (P-Mask) corresponding to the address A2 remains (FF000000). Then, since the constant is not set in the register R2, the constant flag (Const-FLAG) corresponding to the register R2 is reset.

  In the sixth instruction, the address constant A3 is set in the register R0. Since this instruction is an instruction for setting a constant, a constant flag (Const-FLAG) corresponding to the register R0 is set.

  In the seventh instruction, 1-byte data (33) loaded from the main memory 3 having the contents of the register R0 as an address is stored in the register R3. In this case, the address A3, the mask (00FF0000), and the data (33) are registered as inputs in the third column on the Input side in the RB. Register number R3, mask (FFFFFFFF), and data (00000033) are registered as outputs in the third column on the Output side of RB.

  Since the constant flag (Const-FLAG) corresponding to the register R0 used as the address is set, the history mask (P-Mask) corresponding to the address A3 is set. Here, since the target data is 1-byte data of (33), (00FF0000) is set in the history mask (P-Mask) corresponding to address A3 corresponding to this. Since the constant is not set in the register R3, the constant flag (Const-FLAG) corresponding to the register R3 is reset.

  In the eighth instruction, 1-byte data (44) loaded from the address (R1 + R2) is stored in the register R4. In this case, since the addresses R1 and R2 are the addresses of the registers overwritten inside the instruction section, the addresses R1 and R2 are not input to the instruction section. On the other hand, since the address A4 generated by the address (R1 + R2) is an input in the instruction section, the address A4, the mask (00FF0000), and the data (44) are registered as inputs in the fourth column on the Input side in the RB. Register number R4, mask (FFFFFFFF), and data (00000044) are registered as outputs in the fourth column on the Output side of RB.

  Since the constant flags (Const-FLAG) corresponding to the registers R1 and R2 used as addresses are reset, the history mask (P-Mask) corresponding to the address A4 is not set. That is, the history mask (P-Mask) corresponding to the address A4 is (00000000). Since the constant is not set in the register R4, the constant flag (Const-FLAG) corresponding to the register R4 is reset.

  In the ninth instruction, the value is read from the register R5, and the result obtained by adding 1 to the read value is stored in the register R5 again. In this case, register R5, mask (FFFFFFFF), and data (00000100) are registered as inputs in the fifth column on the Input side of RB. Register number R5, mask (FFFFFFFF), and data (00000101) are registered as outputs in the fifth column on the Output side of RB. At this time, since the constant is not set in the register R5, the constant flag (Const-FLAG) corresponding to the register R5 is reset.

  Thereafter, it is assumed that a store instruction is executed for the address A2 and the address A3, and a change flag (C-FLAG) is set for the address A2 and the address A3.

  As a result, the mask position where the change flag (C-FLAG) is set and the history mask (P-Mask) is set is only the first byte of the address A2 and the second byte of the address A3. An address, a mask, and a value corresponding only to this mask position are recorded in the RB entry as history information that holds a past input history for each command section as a prediction target. The registers registered in the RB input pattern are unconditionally recorded as a history as a prediction target.

  FIG. 11 shows an example in which the command section shown in FIG. 20 is repeatedly registered and registered in the RB as a history. As shown in the figure, RB includes a history mask (P-Mask) in the column of address A2 (FF000000), a column of address A3 as a history mask (P-Mask) (00FF0000), and a column of address R5. (FFFFFFFF) is stored as a history mask (P-Mask). Then, while Time changes from 1 to 4, the value corresponding to the history mask (P-Mask) at each address changes. The diff shown between the histories indicates the amount of change (difference) in the value of the corresponding input element. This diff is calculated by the prediction processing unit 2B.

  In the example shown in the figure, for the column of address A2 and address R5, all diffs are 01 while Time changes from 1 to 4. Therefore, the values corresponding to these addresses are expected to increase by 01 per unit time. On the other hand, for the column of address A3, diff is 00 or 02 while Time changes from 1 to 4. Therefore, it can be seen that it is difficult to predict the address A3.

  As described above, the prediction processing unit 2B performs prediction assuming that the difference continues after that for the address where the difference is constant in the history, and the difference is not constant or the difference becomes zero. Do not make predictions about existing addresses.

  FIG. 12 shows the state of the input element recorded in the RB as a prediction entry when the prediction processing unit 2B makes a prediction regarding the values of the address A2 and the address R5 based on the above prediction. In the figure, the address (A2 + 4) and the address A3 are obtained by directly referring to the main memory 3 without obtaining a predicted value.

  When the predicted value of the input element is calculated in this way, the SSP 1B calculates the output element by executing the instruction interval based on the predicted input element, and this predicted output element is stored in the RB as a predicted entry. . After that, when the instruction interval is executed by the MSP 1A and the same input value as the prediction input element stored in the RB is input as the prediction entry, the reuse is realized by outputting the corresponding prediction output element. It will be.

(Second configuration example of RF / RB)
Next, a second configuration example of RF / RB 2 will be described below with reference to FIG. As shown in the figure, RF / RB2 has a configuration including RB, RF, RO1 (second output pattern storage means), and RO2 (first output pattern storage means).

  The RB includes a value (value storage area) for storing a register value or a main memory input value, which is a value to be compared, and a key (key storage area) for storing a key number. There are multiple.

  RF is an end flag E indicating that there is no register number or main memory address to be compared next, a comparison required flag indicating that the contents of the register number or main memory address to be compared next is updated, and then comparing R / M indicating whether the object to be registered is a register or main memory, Adr. (Search item designation area) indicating the register number or main memory address to be compared next, UP indicating the line number referenced immediately before (stored in parent node) Area), Alt. (Comparison item specification area) indicating the register number or main memory address to be compared with priority over the register number or main memory address to be compared next, and necessary for priority comparison DN (comparison key designation area) indicating a correct key is provided corresponding to each line in the RB.

  RO1 and RO2 store an output value to be output to the main memory and / or a register when it is determined that reuse is possible based on the search results by RB and RF. RO1 stores an output value and an address to be output in one-to-one correspondence with each line of RF. RO2 stores output values and addresses to be output when the output values cannot be stored by RO1 alone. When it is necessary to read the output value from RO2, a pointer storing the output value at RO2 is shown in the corresponding line at RO1, and the output value is read from RO2 using this pointer. . Moreover, RB and RF are comprised by CAM and RAM, respectively.

(Associative search operation in the second configuration example)
Next, an associative search operation in the second configuration example will be described. In the configuration shown in FIG. 1, the horizontal row as each entry in the RB includes all items of input values to be subjected to matching comparison. That is, all input patterns are registered in the RB as one row.

  On the other hand, in the second configuration example, items of input values to be subjected to coincidence comparison are divided into short units, each comparison unit is regarded as a node, and an input pattern is registered in RF and RB as a tree structure. It has become. Then, when reusing, by sequentially selecting matching nodes, it is determined whether or not reusable is finally possible. In other words, portions common to a plurality of input patterns are combined into one and associated with one line of RF and RB.

  As a result, redundancy can be eliminated and the utilization efficiency of the memory constituting the RF / RB 2 can be improved. Also, since the input pattern has a tree structure, it is not necessary to associate one input pattern with an entry as one row in the RB. Therefore, it is possible to vary the number of input value items to be subjected to coincidence comparison.

  Also, since RF and RB register their input patterns as a tree structure, multimatching is not performed when matching comparison is performed. That is, the instruction interval storage unit 2 can be realized as long as it is an associative search memory having a single match mechanism. Here, while an associative search memory having only a single match mechanism is generally marketed, an associative search memory capable of reporting multimatches with the same performance as a single match is not generally marketed. That is, according to the second configuration example, since a commercially available associative search memory can be used, the data processing apparatus according to the present embodiment can be realized in a shorter period of time and at a lower cost.

  Next, a specific example of the associative search operation in RF / RB2 will be described with reference to FIG. First, when execution of an instruction interval is detected, a program counter (PC) and register contents (Reg.) Are input to the RB. Then, in the RB, these values inputted by the associative search are compared with the instruction section start address and the register value registered in the Value column of the RB, and the only line (line) in which the values match is found. Selected as a candidate (match line). In this example, the “01” line in the RB is selected as the match line.

  Next, “01”, which is the address in the RB of the line selected as the match line, is transmitted to the RF as an encoding result, and the line in the RF corresponding to the key 01 is referred to. In the RF line corresponding to the key 01, the comparison required flag is “0”, and the main storage address to be compared is A1. That is, it is not necessary to perform a coincidence comparison on the main memory address A1.

  Next, using the key 01, a search is performed on the Key column in the RB. In this example, the line “03” in RB is selected as the match line. Then, the key 03 is transmitted to the RF as an encoding result, and the line in the RF corresponding to the key 03 is referred to. In the RF line corresponding to the key 03, the comparison required flag is “1”, and the main storage address to be compared is A2. That is, it is necessary to perform a coincidence comparison on the main memory address A2. Here, the value of the main memory address A2 in the main memory 3 is read via the Cache 7A, and in RB, the value is the value read from the main memory 3, and the key is “03”. A line is searched. In the example shown in FIG. 14, there are two lines “04” and “05” with Key “03”, but the value read from the main memory 3 is “00”. "Is selected as a match line, and the key 05 is transmitted to the RF as an encoding result.

  When the above processing is repeated and a termination flag E indicating that there is no register number or main memory address to be compared next is detected in RF, it is determined that all the input patterns match, and the corresponding instruction section Is determined to be reusable. Then, a “Select Output” signal is output from the line in which the termination flag E is detected, and output values corresponding to the lines stored in RO1 and RO2 are output to the register 6A and the main memory 3.

As described above, the associative search operation according to the second configuration example has the following characteristics. First, since there is only one match line in the RB indicating that the contents match, it is only necessary to transmit one encoded result when propagating the search operation to the next column. Therefore, one set (N) of signal lines connecting the RB and the RF may be sufficient as the result of address encoding. On the other hand, in the example shown in FIG. 1 described above, since multi-matching is allowed in the RB, the signal lines that connect the columns in the RB need to be provided for each line ( ^2N lines). It will be. That is, according to the second configuration example, the number of signal lines in the associative search memory configuring the RF / RB 2 can be significantly reduced.

  Further, since only a single match is allowed during the search, the comparison order of items to be compared is limited to the reference order in the tree structure. That is, it is necessary to compare the register value and the memory contents while mixing them in the reference order.

  The input pattern is registered in RB and RF by a tree structure by linking each item in the form of Key to be referred to. Further, the end of the input pattern item is indicated by the end flag. Therefore, since the number of input pattern items can be made variable, the number of input pattern items can be flexibly set in accordance with the state of the command section to be registered in the reuse table. In addition, since the number of items in the input pattern is not fixed, the unused area does not occupy the memory area unnecessarily, and the use efficiency of the memory area can be improved.

  In addition, since the input pattern is registered by the tree structure, it is possible to share one line with a plurality of input patterns for portions where the contents of the items overlap. Therefore, the utilization efficiency of the memory area can be further improved.

  In the case of the above configuration, the memory constituting the RF and RB has a vertically long structure. For example, when the memory capacity is 2 Mbytes, the horizontal is 8 words and the vertical is 65536 lines.

(Another example of associative search)
In the above example, the items UP, Alt., And DN are not used in the RF shown in FIG. That is, in the above example, it is not necessary to provide these items in the RF. On the other hand, a configuration and operation for further speeding up the associative search operation by using items of UP, Alt., And DN will be described below.

  First, in FIG. 15B, only the program counter (PC) and the contents of the register (Reg.) Are compared. If they match, the section can be reused without comparing the main memory values. Indicates the state when it can be determined that there is. In this state, first, PC and Reg. Are registered in Value in the RB “01” line. In the RF “01” line, the termination flag is “E” and the comparison required flag is “0”. The main storage address to be compared is “A1”, and the UP indicating the parent node number is “FF”. In the RB “03” line, the Key is “01” without the Value value, and in the RF “03” line, the termination flag is “E”, the comparison required flag is “0”, The main storage address to be compared is “A2”, and the UP indicating the parent node number is “FF”. Thereafter, similarly, the “05” line and the “07” line in the RB and RF are registered, the termination flag is “E”, and the comparison required flag is “0”, respectively.

  In this state, when execution of a certain instruction section is detected, PC and Reg. Are input to the RB, and the line “01” in the RB is selected as a match line. Then, “01” which is the address in the RB of the line selected as the match line is transmitted to the RF as an encoding result, and the line in the RF corresponding to the key 01 is referred to. Since the end flag is “E” in the RF line corresponding to the key 01, it can be seen that there is no main memory address to be compared next. Further, since the comparison required flag is “0”, it can be seen that it is not necessary to compare the main memory address A1.

  Therefore, as shown in the tree structure of FIG. 15 (a), when the coincidence of PC and Reg. Is confirmed in S1, comparison is performed at main storage addresses A1, A2, and A3 as in the node indicated by Tr1. Instead, the corresponding output value is output.

  When RF and RB are in this state, it is assumed that writing has been performed on the main memory address A2. In this case, it is not necessary to perform a coincidence comparison of the main memory address A2 at the time of registering the input pattern in the RF and RB, but a coincidence comparison of the main memory address A2 is performed by changing the main memory address A2. There will be a need. Therefore, in this case, RF and RB are changed as shown in FIG.

First, using A2 which is the main memory address whose contents are changed as a key, Adr.
A search is performed on the columns. As a result, the line “03” in RF is selected. Then, in the selected line “03”, the comparison required flag is set to “1” and the end flag “E” is deleted.

  Next, by referring to the UP in the “03” line, the “01” line as the parent node is recognized. In the line “01”, A2 which is the main storage address whose contents are changed is written to Alt. Indicating the main storage address to be compared with priority over the main storage address to be compared next. The termination flag “E” is deleted. Further, in the “01” line, “03” is written in the DN indicating the key required for the priority comparison.

  The associative search operation when RF and RB are rewritten as described above is as follows. When a certain instruction section is detected, first, PC and Reg. Are input to RB. Then, in the RB, these values input by the associative search are compared with the instruction section start address and register value registered in the Value column of the RB, and the “01” line in the RB is used as a match line. Selected.

  Next, “01”, which is the address in the RB of the line selected as the match line, is transmitted to the RF as an encoding result, and the line in the RF corresponding to the key 01 is referred to. In the RF line corresponding to the key 01, the comparison required flag is “0”, and the main storage address to be compared is A1. That is, it can be seen that it is not necessary to perform a coincidence comparison with respect to the main memory address A1.

  Also, the main memory address A2 is registered in Alt. Indicating the main memory address to be compared with priority over the main memory address to be compared next, and DN indicating the key required for the priority comparison It is confirmed that “03” is registered in. In this case, the value of the main memory address A2 in the main memory 3 is read through the Cache 7A, and in RB, Value is the value read from the main memory 3, and Key is indicated in DN. A line with “03” is searched.

  In the example shown in FIG. 16B, there are two lines with “03” Key “04” and “05”, but the value read from the main memory 3 is “00”. , “05” is selected as a match line, and key 05 is transmitted to RF as an encoding result. In the line in RF corresponding to the key 05, since the termination flag is “E”, it is determined that all the input patterns match, and the corresponding command section is determined to be reusable. Then, a “Select Output” signal is output from the line in which the termination flag E is detected, and output values corresponding to the lines stored in RO1 and RO2 are output to the register 6A and the main memory 3.

  According to the associative search operation as described above, in RF, Alt. Indicating the main memory address to be compared with priority over the main memory address to be compared next, and the key necessary for the priority comparison Therefore, it is possible to skip the search by the contents of the main storage address A1 and the key 01 and the search by the contents of the main storage address A2 and the key 03. Accordingly, the processing steps of the search operation can be reduced, and the processing speed can be increased.

(Output value storage means)
In the above description, the input pattern of the instruction section is registered in RF and RB, and the associative search operation is performed. However, in the following, the output value output as reuse is stored after the input pattern match is confirmed. The means to do will be described. As described above with reference to FIG. 13, the instruction interval storage unit 2 stores an output value for storing an output value to be output to the main memory and / or the register when it is determined that reuse is possible. RO1 and RO2 are provided as storage means.

  The output value can be obtained by referring to storage means such as a RAM for storing the output value based on the address output from the RF and RB. However, like the input pattern, it is preferable that the number of output value items be variable for the output pattern, and thus a device for storing the output value needs to be devised.

  The input pattern is registered in a tree structure in RF and RB. Then, it is determined that reuse is possible in the line that is the end of the tree structure, that is, the line in which the end flag E is registered. Therefore, by registering a pointer in the output value storage means for storing the output value to be output in each line in which the termination flag E is registered, it is possible to perform an output operation at the time of reuse. .

  However, when the storage position in the output value storage unit is specified based on the pointer storing the output value when it is confirmed that all the input patterns match, the storage position is specified based on the pointer. Conversion processing is required, which causes a reduction in processing speed.

  Therefore, in the present embodiment, two storage means, RO1 and RO2, are provided as output value storage means. RO1 stores an output value and an address to be output in a one-to-one correspondence with each line of RF. That is, when it is determined that the RF line in which the termination flag E is registered can be reused, the RO1 line corresponding to the line is selected and the output value is output.

  However, in this way, when the output value storage means stores the output value and the address to be output in one-to-one correspondence with each line of the RF, the RF in which the termination flag E is not registered in the RF A memory area is secured in RO1 for these lines. Further, since the output value is stored in RO1 corresponding to all the lines of the RF in which the termination flag E is registered, there is a redundancy that the same contents are stored in a plurality of places. Become. Therefore, RO1 is excellent in terms of processing at high speed, but it is not good in terms of memory utilization efficiency.

  In order to solve this problem, the number of items that can be registered in RO1, that is, the number of pairs of output values and output addresses is set to be small (two in the example of FIG. 13), and output that cannot be registered in RO1. A set of a value and an output address is registered in RO2 having a configuration in which a storage area is designated using a pointer.

  In RO2, since the storage area is indicated by the pointer, there is almost no unused memory area. Also, when registering multiple sets of output values and output addresses, you can connect them sequentially using pointers, so the number of sets of output values and output addresses that can be registered can be made variable. It is. Furthermore, since a pointer indicating the same storage position in RO2 can be designated from a plurality of lines in RO1, storage information in RO2 can also be shared by a plurality of lines in RO1. Therefore, in RO2, the redundancy of stored contents can be reduced.

  As described above, by providing two output value storage units, RO1 and RO2, when the number of output value items is small, the processing speed can be increased by using only RO1, and the number of output value items is large. The case is dealt with by using RO2, which can change the number of items. Therefore, according to the above configuration, it is possible to realize high-speed processing and improvement in memory utilization efficiency.

(Registration processing for the command section storage unit)
In the above, the operation in the case of reusing when executing a certain instruction section has been described. In the following, an operation when registering input / output in an instruction section in RF, RB, RO1, and RO2 when it is determined that reuse cannot be performed when executing a certain instruction section will be described.

  First, when execution of a certain instruction section is detected, the values of PC and Reg. Are input to RB. Then, in the RB, these values inputted by the associative search are compared with the instruction section start address and the register value registered in the Value column of the RB. Here, if it is determined that there is no RB Value column that matches the input value, it is determined that the instruction section cannot be reused, and the arithmetic unit 5A performs arithmetic processing. Is called. Then, the register input value, the main memory input value, the main memory output value, and the register output value that are used until the calculation process of the corresponding instruction section is completed are registered in RB, RF, RO1, and RO2 as necessary. . Here, when registering in RB and RF, registration is performed so that each item corresponds to one line so as to have the tree structure as described above. Then, in the line where the last item of the input pattern to be registered is registered, the RF termination flag is set to “E”, and the registration of the input pattern is completed.

  On the other hand, if an item that matches the entered PC and Reg. Values is registered in the RB Value column, the next item to be compared is compared in the same manner as the associative search operation described above. A match comparison is performed. In this way, the comparison between the input pattern registered in RB and RF and the input pattern in the corresponding instruction section is continued, and a new node is added when an unmatched item occurs. Then, registration is performed in the RB and RF for the mismatched items. Then, in the line where the last item of the input pattern to be registered is registered, the RF termination flag is set to “E”, and the registration of the input pattern is completed.

  When the registration of the input pattern is completed, the output value and the output address are registered in the line in RO1 corresponding to the line in RF whose end flag is “E”. When items to be registered as output values cannot be registered in RO1, registration is performed for RO2 using a pointer. Thus, the instruction section registration process is completed.

(Prediction mechanism in the second configuration example)
In the second configuration example, the locations for temporarily storing the input / output pattern during execution of the instruction section are RW4A and 4B. Here, in the first configuration example described above, since the input / output pattern at the time of execution of the instruction section is directly registered in the RB, the RWs 4A and 4B are realized by pointers to each row of the RB. On the other hand, in the second configuration example, since RF and RB are configured by a tree structure, RW 4A and 4B cannot directly point to the row of RB. In other words, in the second configuration example, the RWs 4A and 4B do not function as pointers to the respective rows of the RBs, but function as substantial memories that temporarily store input / output patterns at the time of execution of instruction sections. Become.

  Although not shown in FIG. 13, in the second configuration example as shown in FIG. 1 as a temporary storage memory area for storing a history entry of an input pattern when a predetermined instruction section is repeatedly executed. RF and RB are provided. However, in this case, the row of entries in the RB is composed of several rows as history storage rows for storing history entries.

  When the command section is executed, the input elements are sequentially stored in the RW 4A and 4B, and when all the input elements are prepared and the output elements are determined by performing the operation, this input / output pattern is stored in the history storage line. In addition to being stored, it is stored in the tree-structured input / output pattern storage mechanism as described above.

  Further, when a predetermined command section is repeatedly executed, it is sequentially stored in the history storage line, and when a predetermined number of histories are stored, the prediction processing unit 2B performs prediction as described above, and the prediction The result executed by the SSP 1B based on the above is stored in the tree-structured input / output pattern storage mechanism as described above.

(Application example of the present invention)
In order to apply the data processing apparatus according to the present invention to other instruction set architectures, assuming that there is a program execution environment in which the global variable area and the stack area can be distinguished by “LIMIT” or the like, There is a need for a means of distinguishing whether a variable is a local variable of an upper / lower function. In particular, if there are not enough registers to store arguments and arguments are stored on the stack, the called function cannot make this distinction.

  In the SPARC processor taken up in this embodiment, the first 6 words of the argument are stored in the general-purpose register, and the function that handles the argument of 6 words or more does not appear frequently, and when the argument overflows the stack. By utilizing both of the fact that reuse becomes impossible, function / loop reuse is realized. Similar to the SPARC processor, many RISC processors having 32 or more general-purpose registers can realize the reuse of the function / loop as in the present invention by making the same determination.

  The data processing apparatus according to the present invention can be applied to the SPARC processor as described above. Further, like the SPARC processor, the present invention can be applied to many RISC processors having 32 or more general-purpose registers. Further, the present invention can be applied to game machines, portable telephones, information home appliances, and the like provided with such a processor.

It is a figure which shows the reuse table implement | achieved by RF / RB with which the data processor which concerns on one Embodiment of this invention is provided. It is a block diagram which shows schematic structure of the said data processor. It is a flowchart which shows the flow of a process in case it is a function call instruction as a result of decoding an instruction. It is a flowchart which shows the flow of a process in case it is a function return instruction as a result of decoding an instruction. It is a flowchart which shows the flow of a process in case a back branch is taken as a result of decoding an instruction. It is a flowchart which shows the flow of a process when back branch is not established as a result of decoding an instruction. It is a figure which shows an example of the state where the function and the loop are nested. It is a figure which shows the influence range from which the register input / output of an inner structure turns into the register input / output of an outer structure in the nested structure of a function. It is a figure which shows the relationship between RW and RF * RB. It is a figure which shows the actual registration condition in RB when a certain command area is performed. It is a figure which shows the example registered into RB as a log | history when a certain command area is repeatedly performed. It is a figure which shows the state of the input element recorded on RB as a prediction entry when a prediction process part estimates about the value of address A2 and address R5 based on prediction. It is a figure which shows the outline of the 2nd structural example of RF / RB. It is a figure which shows the specific example of the associative search operation | movement in RF / RB shown in FIG. FIG. 7B is a diagram showing another specific example of the associative search operation in the RF / RB shown in FIG. 13, and FIG. 9A shows the associative search operation in FIG. 13B as a tree structure. FIG. FIG. 7B is a diagram showing still another specific example of the associative search operation in the RF / RB shown in FIG. 13, and FIG. 9A shows the associative search operation in FIG. FIG. FIG. 4A is a conceptual diagram conceptually showing a structure in which the function A calls the function B, and FIG. 4B shows a memory in the main memory when executing the program structure shown in FIG. It is a figure which shows a map. It is a figure which shows the outline | summary of the argument and frame in a memory map when the function A calls the function B. It is a figure which shows the conventional reuse table for reusing one function. It is a figure which shows an example of an instruction area. FIG. 21 is a diagram showing, in a simplified manner, input addresses and input data, and output addresses and output data that are registered in an RB when the instruction section shown in FIG. 20 is executed. It is a figure which shows the actual registration condition in RB. It is a figure which shows the example of the log | history registered on the input side of RB when the command area shown in FIG. 20 is repeatedly performed. It is a figure which shows the prediction result by the conventional input prediction.

Explanation of symbols

1A MSP
1B SSP
2 RF / RB (input / output storage means)
2A RB registration processing unit (discrimination processing means)
2B prediction processing unit (prediction processing means)
3 Main memory (main memory means)
4A ・ 4B RW
5A / 5B computing unit (first and second computing means)
6A ・ 6B Register 7A ・ 7B Cache

Claims (8)

In a data processing apparatus that reads a command section from a main storage means and performs a process of writing a result of arithmetic processing to the main storage means,
First calculation means for performing an operation based on an instruction section read from the main storage means, a register used when reading and writing to the main storage means by the first calculation means, and execution results of a plurality of instruction sections Input / output storage means for storing the input pattern and output pattern of
When the first calculation means executes an instruction section, if the input pattern of the instruction section matches the input pattern stored in the input / output storage means, the first calculation means corresponds to the input pattern. Reuse processing for outputting the output pattern stored in the entry output storage means to the register and / or the main storage means,
The data processing device is
Of the input elements included in the input pattern, the input elements that should be predicted and the input elements that do not need to be predicted, when the execution result of the instruction section by the first calculation means is stored in the input / output storage means Distinction processing means for registering this distinction information in the input / output storage means,
Prediction processing means for predicting a change in the value of an input element to be predicted among the input elements stored in the input / output storage means based on the distinction information;
Based on the input element predicted by the prediction processing means, further comprising a second calculation means for executing the corresponding instruction section in advance,
The pre-execution result of the instruction section by the second calculation means is stored in the input / output storage means ,
When the distinction processing means is used as a stack pointer or a frame pointer for each address of the register used for input, and when the write instruction for the address is an instruction for setting a constant, the corresponding address On the other hand, a data processing apparatus is characterized in that a constant flag is set as distinction information indicating an input element to be predicted, and in the other cases, the constant flag is reset for the corresponding address . In a data processing apparatus that reads a command section from a main storage means and performs a process of writing a result of arithmetic processing to the main storage means,
First calculation means for performing an operation based on an instruction section read from the main storage means, a register used when reading and writing to the main storage means by the first calculation means, and execution results of a plurality of instruction sections Input / output storage means for storing the input pattern and output pattern of
When the first calculation means executes an instruction section, if the input pattern of the instruction section matches the input pattern stored in the input / output storage means, the first calculation means corresponds to the input pattern. Reuse processing for outputting the output pattern stored in the entry output storage means to the register and / or the main storage means,
The data processing device is
Of the input elements included in the input pattern, the input elements that should be predicted and the input elements that do not need to be predicted, when the execution result of the instruction section by the first calculation means is stored in the input / output storage means Distinction processing means for registering this distinction information in the input / output storage means,
Prediction processing means for predicting a change in the value of an input element to be predicted among the input elements stored in the input / output storage means based on the distinction information;
Based on the input element predicted by the prediction processing means, further comprising a second calculation means for executing the corresponding instruction section in advance,
The pre-execution result of the instruction section by the second calculation means is stored in the input / output storage means ,
When the discrimination processing means newly stores an input element in the input / output storage means, the change flag as the discrimination information indicating the input element to be predicted is reset for the address of the input element, A data processing apparatus, wherein when the store instruction is executed for the corresponding address after being stored in the input / output storage means, the change flag is set for the corresponding address. When the discrimination processing means newly stores an input element in the input / output storage means, the change flag as the discrimination information indicating the input element to be predicted is reset for the address of the input element , after being stored in the input storage means, when the store instruction for the corresponding address is performed, the corresponding address data processing apparatus according to claim 1, wherein the setting the change flag for. When the discrimination processing means newly stores an input element in the input / output storage means, the history flag as the discrimination information indicating the input element to be predicted is reset for the address of the input element , at load instruction to said address, when the constant flag is set in the register address that generated the address, data processing according to claim 1, wherein the setting the history flag with respect to the address apparatus. When the input processing unit newly stores the input element in the input / output storage unit, the discrimination processing unit resets a change flag as the discrimination information for the address of the input element and stores the change flag in the input / output storage unit Later, when a store instruction is executed for the corresponding address, a change flag is set for the corresponding address.
The prediction processing means predicts the change of the input element with respect to the address in which the change flag is set and the history flag is set among the addresses of the input elements stored in the input / output storage means. 5. A data processing apparatus according to claim 4, wherein: The prediction processing means predicts a change in the value of an input element only for an input element stored in the input / output storage means and whose value change in the history of the input element is not zero. the data processing apparatus according to claim 1 or 2, wherein the performing.   A data processing program for causing a computer to execute processing performed by each means included in the data processing apparatus according to claim 1. A computer-readable recording medium on which the data processing program according to claim 7 is recorded.

Images