Digital computer for executing multiple instruction sets in a simultaneous-interleaved fashion
BACKGROUND OF THE INVENTION 
     This invention relates to computer-implemented methods of transforming assignment statements of a relatively high level source language into relatively low level object language instructions; and it relates to digital computers for executing the low level object language instructions. 
     One prior art method of transforming a high level source language assignment statement into low level object language instructions is illustrated schematically in FIG. 1. There, reference numeral 10 indicates the assignment statement that is to be transformed; reference numeral 11 indicates the digital computer which receives and transforms statement 10; reference numeral 12 indicates the set of low level object language instructions into which statement 10 is transformed; and reference numerals I1-I47 indicate the individual instructions in set 12. 
     Assignment statements, such as statement 10, are part of high level languages called FORTRAN, ALGOL, PASCAL, COBOL, C, PL1, and PL/M-80. They are written by an individual called a programmer, and they provide the means by which the programmer specifies the operations that he desires the computer to perform. 
     A characteristic feature of assignment statements is that they assign a value to a variable; and the assigned value is expressed as a mathematical function of one or more other variables and/or constants. In statement 10, for example, the variable ABLE is assigned a value that is expressed as: BAKER(J,I)+CHARLIE(K)-DELTA(J 2  +I+3)+EASY-5+FOX(I,J,K) where BAKER, CHARLIE, DELTA, EASY, and FOX also are variables. 
     Digital computers generally do not execute assignment statements directly because their format is too complex. Instead, assignment statements are transformed prior to their execution into lower level object language instructions having a simpler format. This transformation is performed by a computer-implemented process under the direction of a program called a compiler. 
     In FIG. 1, the compiler program is indicated by reference numeral 13. Compiler program 13 is stored in a memory 14; and it directs computer 11 to carry out all of the steps by which the high level language statements are transformed into the low level language instructions. 
     One of the tasks of compiler 13 is to provide memory addresses for each of the variables in the assignment statement. In FIG. 1, for example, instructions I1-I9 compute the address of BAKER(J,I); instructions I11-I14 compute the address of CHARLIE(K); instructions I17-I23 compute the address of DELTA(J 2  -I+3); and instructions I30-I43 compute the address of FOX(I,J,K). 
     Variables BAKER, CHARLIE, DELTA, and FOX are all indexed variables. As such, they each represent an N-dimensional matrix where N is the number of indices associated with the variable. BAKER has two indices, J and I, so it represents a two-dimensional matrix; CHARLIE and DELTA have one indice, so they each represent a one-dimensional matrix; and FOX has three indices, I, J, K, so it represents a three-dimensional matrix. 
     Another task of compiler 13 is to generate low level object language instructions which perform arithmetic operations as specified in statement 10 on the addressed variables. FIG. 1 shows that after variable B is addressed, instruction I10 fetches variable BAKER; and after variable CHARLIE is addressed, instructions I15-I16 add variable CHARLIE to variable BAKER. Similarly, address calculations for the variables DELTA, EASY, and FOX respectively are followed by instructions I24-I25, I27-I29, and I44-I47 which arithmetically combine those variables as specified in statement 10. 
     A problem, however, with the above-described compiler-generated instructions I1-I47 is that some of the information which is implicitly contained in the original assignment statement 10 is lost by the compilation process. For example, implicit in statement 10 is the fact that the variables BAKER, CHARLIE, DELTA, EASY and FOX can be combined in any order, and the fact that the variables can be combined by parallel sub-operations. Yet, neither of these facts is apparent from inspection of the compiled instructions I1-I47. Consequently, the compiled instructions I1-I47 are executed one at a time in a serial fashion, which in turn adversely limits their minimal execution time. 
     BRIEF SUMMARY OF THE INVENTION 
     Accordingly, a primary object of the invention is to provide an improved digital computer system for executing relatively low level language instructions representing higher level language statements. 
     Another object of the invention is to provide a digital computer system for executing multiple low level language instruction sets in an interleaved-simultaneous fashion to achieve an improved execution speed. 
     In the present invention, these and other objects are achieved by providing a digital computer system for executing instructions of a first set in an interleaved fashion with instructions of second and third sets, the latter two of which are executed at the same time. One embodiment of such computer system includes a computer for fetching any instruction of the first set and for determining if the fetched instruction references two encoded addresses having the same predetermined code. Each encoded address has address bits which locate respective items in a memory, and has code bits which identify the nature of the items. Said predetermined code indicates that the respective items are instructions in the second and third sets that compute addresses of two variables. Also included is a pair of computers for temporarily suspending operations on the fetched instruction in the first set if its referenced encoded addresses have said same predetermined code, and simultaneously executing the instructions of the second and third sets as located by the address bits in the referenced encoded addresses to compute the addresses of two variables. Further included is another computer for continuing operations on the fetched instruction in the first set after the instructions in the second and third sets have been simultaneously executed by performing a mathematical operation on the two variables as specified by the fetched instruction of the first set. 
     Another embodiment of such digital computer system includes a computer for fetching any instruction of the first set and determining if the fetched instruction references two encoded addresses respectively having first and second predetermined codes. Each encoded address had address bits which locate respective items in a memory, and has code bits which identify the nature of the items. Said first predetermined code indicates the item is a variable, and said second code indicates the item is instructions in the second set that compute the address of another variable. Also included is a pair of computers for temporarily suspending operations on the fetched instruction of the first set if the encoded addresses have said first and second predetermined code and executing the instructions of the second set as located by the encoded address with said second predetermined code to compute the address of the other variable. Another computer is included for continuing operations of the fetched instruction in the first set after the instructions of the second set have been executed by performing a mathematic operation specified by the fetched instruction on the variables. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     Various features and advantages of the invention will best be understood by reference to the following detailed description and accompanying drawings wherein: 
     FIG. 1 is a diagram illustrating the transformation of a relatively high level language source statement into relatively low level language instructions as such transformation is carried out by a prior art compilation process; 
     FIGS. 2, 2A and 2B constitute a diagram illustrating the transformation of a high level language source statement into multiple sets of relatively low level object language instructions as such transformation is carried out according to the present invention. 
     FIGS. 3, 3A and 3B constitute a flow chart illustrating the major steps of the language transformation process of FIG. 2; 
     FIG. 4 illustrates a digital computer system constructed according to the invention for executing, in an interleaved parallel fashion, the multiple low level language instruction sets that are generated by the process of FIG. 2; 
     FIGS. 5, 5A, 5B and 5C are diagrams illustrating the sequence by which each of the processors in the system of FIG. 4 executes the various instructions in the multiple instruction sets that are generated by the FIG. 2 process. 
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
     One preferred method, according to the invention, of transforming high level source language statements into lower level object language instructions will now be described in detail in conjunction with FIG. 2. In this method, all of the steps of the language transformation process are carried out by computer 11 under the direction of a novel compiler program 21 which is stored in a memory 20. 
     Those steps which compiler program 21 direct computer 11 to perform include the generation of a NAME TABLE, and the generation of three different sets of low level object language instructions. These three sets of object language instructions are identified in FIG. 2 as X-CODE, Y-CODE, and Z-CODE instructions; and they are generated such that the X-CODE instructions are executable in an interleaved fashion with Y-CODE and Z-CODE instructions, the latter two of which are executable at the same time. 
     To generate the NAME TABLE, respective NAME TABLE ENTRIES (NTE) are generated for each variable in the assignment statement that is to be transformed. Each NAME TABLE ENTRY is in the form of an encoded address. A code of 11 indicates that the address is of instructions which compute the address of the corresponding variable; whereas a code of 00 indicates that the address is of the corresponding variable itself. 
     For example, in the NAME TABLE of FIG. 2, entry 22 corresponds to the variable CHARLIE(K). Entry 22 has a code of 11 and an address of Z10. This indicates that address Z10 is the beginning address of a set of instructions which compute the address of the variable CHARLIE(K). By comparison, entry 26 corresponds to the variable EASY; and it has a code of 00 and an address of Y15. This indicates that address Y15 is the address of the variable EASY. 
     Preferably, a code of 11 is assigned to a NAME TABLE ENTRY if the variable corresponding to that entry is indexed. Thus, entries 22, 23, 24, and 25 all have codes of 11 since the corresponding variables of CHARLIE, BAKER, FOX, and DELTA are all indexed. By comparison, the code of 00 preferably is assigned to an entry in the NAME TABLE if the corresponding variable is non-indexed. Thus, entries 26, 27, 28, and 29 all have codes of 00 since the corresponding variables of EASY, I, J, and K are all non-indexed. 
     As another step of compilation process, compiler 21 directs computer 11 to generate the Y-CODE and Z-CODE instructions. One set of these instructions is generated for each entry in the NAME TABLE having a code of 11. These instructions are stored in respective memories at the addresses given in the NAME TABLE and they compute the address of the corresponding variables. 
     For example, entry 22 in the NAME TABLE has a code of 11. Also, that entry corresponds to the variable CHARLIE(K) and it has an address of Z10. So compiler 21 directs computer 11 to generate object code instructions for storage in memory Z beginning at address 10 which instructions compute the address of the variable CHARLIE(K). 
     Similarly, entry 23 in the NAME TABLE has an 11 code, and corresponds to the variable BAKER(J,I). Also, it has an address Y15, so compiler 21 directs computer 11 to generate instructions in memory Y beginning at address 10 which instructions compute the address of the variable BAKER(J,I). In like manner, compiler 21 directs computer 11 to generate instructions in memory Z beginning at address 30 which compute the address of the variable FOX(I,J,K); and it directs computer 11 to generate instructions beginning at address 40 in memory Y which compute the address of the variable DELTA(J 2  -I+3). 
     As part of each X-CODE and Y-CODE instruction set, the compiler generates a pair of instructions which sends the computed address to a processor P X&#39;   and then returns control back to a predetermined state. This pair of instructions is located at the end of the instruction set. For example, in the instruction set beginning at address 10 in memory Y, this pair of instructions is identified as I19 and I20. 
     As still another step of the compilation process, compiler 21 directs computer 11 to generate the X-CODE instructions. During this step, instructions are generated which combine pairs of variables that occur in the assignment statement that is being compiled and which store the result in a temporary location. After all of the pairs of variables have been combined, other X-CODE instructions are generated which combine pairs of the intermediate results in the manner specified by the assignment statement. By such pair-combining steps, the end result is reached; and it is stored at the address of the variable that is being assigned a new value. 
     For example, in FIG. 2, instruction X1 combines the variables BAKER and CHARLIE and stores the result in a temporary location T1; instruction X2 combines the variables DELTA and FOX and stores the result in a temporary location T2; and instruction X3 combines the remaining variable EASY with the constant &#34;5&#34; and stores the result in a temporary location X3. Thereafter, the intermediate results at locations T1, T2, and T3 are combined in pairs by instructions X4 and X5 to reach the end result; and it is stored at the address of the variable ABLE. 
     Those X-CODE instructions which combine pairs of variables identify the variables that are being combined by referencing appropriate entries in the NAME TABLE. For example, instruction X1 combines the variables BAKER and CHARLIE; and so it references NAME TABLE ENTRIES 22 and 23. Similarly, instruction X2 combines the variables DELTA and FOX; so it references NAME TABLE ENTRIES 24 and 25. Likewise, instruction X3 combines the variable EASY with a constant; and so it references NAME TABLE ENTRY 26. 
     Preferably, X-CODE instructions are generated such that, whenever it is possible, they combine pairs of variables that are indexed. For example, in assignment statement 10 there are a total of four indexed variables, one pair of which is combined by instruction X1 and the other pair of which is combined by instruction X2. Also, the pair of indexed variables referenced in instruction X2 is combined even though they are separated in statement 10 by the non-indexed variable EASY and the constant &#34;5&#34;. 
     From the above, it is apparent that every X-CODE instruction has a very regular format in which two items are combined and stored as another item, and in which each item may be a reference to a NAME TABLE ENTRY or a TEMPORARY LOCATION or a CONSTANT. Suitably, the nature of a particular item is indicated in the X-CODE instruction by concatinating identifier bits to the item. Also suitably, an item in an X-CODE instruction that references a NAME TABLE ENTRY does so by including the location of the desired entry as part of that item. 
     All of the above-described steps and the sequence in which they are carried out by compiler 13 are illustrated in greater detail in the flow chart of FIG. 3. As a first step, compiler 13 directs computer 11 to read a statement from the source code. This step is indicated by reference numeral 41. Thereafter, the compiler directs computer 11 to scan the statement that was read until either a variable or the end of the statement is detected. This step is indicated by reference numeral 42. 
     If a variable is detected, compiler 13 directs computer 11 to scan the NAME TABLE to determine if that same variable had previously been assigned an entry. If an entry already exists, compiler 13 directs computer 11 to continue scanning the statement for another variable. These steps are indicated by reference numerals 43 and 44. 
     On the other hand, if the variable has no entry in the NAME TABLE, compiler 13 directs computer 11 to generate an entry. As part of this process, compiler 13 directs computer 11 to determine whether or not the variable is indexed. If the variable is not indexed, then compiler 13 directs computer 11 to generate a code-address pair in which the address is of the variable itself and the code has a value of 00. This step is indicated by reference numerals 45 and 46. 
     If, however, the variable is indexed, compiler 13 directs computer 11 to generate Y-CODE or Z-CODE instructions which when executed compute the address of the indexed variable. Also, compiler 13 directs computer 11 to generate a code-address pair in which the address is of the beginning of the Y-CODE or Z-CODE instructions, and the code has a value of 11. This step is indicated by reference numerals 47 and 48. 
     All of the above steps are repeated in an iterative fashion until the end of the statement being processed is detected. When that occurs, compiler 13 directs computer 11 to re-scan the statement and detect a pair of indexed variables. This step is indicated by reference numeral 49. 
     When a pair of indexed variables is detected, compiler 13 directs computer 11 to generate an X-CODE instruction which combines those variables in the manner prescribed by the assignment statement and temporarily store the results. Thereafter, computer 11 continues to scan the statement until either another pair of indexed variables is detected (in which case another X-CODE instruction is generated which combines that pair of indexed variables), or until the end of the statement is detected. These steps are indicated by reference numerals 50 and 51. 
     After the end of the statement is detected, compiler 13 directs computer 11 to generate X-CODE instructions which combine any temporarily stored results with any non-indexed variables and constants in the statement. This combining is performed on two items at a time so that the format of each X-CODE instruction remains regular. Then the last X-CODE instruction stores the end result at the address of the variable that is being assigned a new value. This step is indicated by reference numeral 52. 
     Thereafter, compiler 13 directs computer 11 to determine if there are any other statements remaining to be processed in the high level source language. If another statement remains, the entire sequence is repeated; otherwise, the compilation process ends. This step is indicated by reference numeral 53. 
     A computer listing of a compiler for performing the above-described steps is included at the end of this Detailed Description as COMPUTER LISTING 1. This compiler is written in a quasi-Algol language; and it would be stored in a machine-readable fashion in a memory 20, such as a magnetic disk, from which it would be read into computer 11 as needed. Suitable methods for recording the compiler in the memory 20 are described in U.S. Pat. Nos. 3,108,261 and 4,234,897. 
     Referring now to FIG. 4, one preferred embodiment of a computer system for executing the compiled low level X-CODE, Y-CODE, and Z-CODE instructions will be described. Included in this computer are four processors P X , P YZ1 , P YZ2 , and P X&#39; , all of which are intercoupled as a system via a pair of buses 60 and 61. Specifically, bus 60 intercouples respective output ports 62 and 63 on processors P YZ1  and P YZ2  to an input port 64 on processor P X&#39; . And bus 61 intercouples an output port 65 on processor P X  to respective input ports 66, 67, and 68 on processors P YZ1 , P YZ2 , and P X&#39; . Preferably, input ports 64 and 68 each include a queue for buffering several messages from the buses 60 and 61. 
     Memories 70-76 are also included in the digital computer of FIG. 4. Memory 70 contains the X-CODE instructions and is coupled to processor P X . Memories 71 and 72 respectively contain the Y-CODE and Z-CODE instructions and are coupled to processor P YZ1 . Similarly, memories 73 and 74 respectively contain the Y-CODE and Z-CODE instructions and are coupled to processor P YZ2 . 
     Memory 75 contains the NAME TABLE and is coupled via respective buses to processors P X , P YZ1  and P YZ2 . And lastly, memory 76 contains data and is coupled via respective buses to processors P YZ1 , P YZ2 , and P X&#39; . All of the above-mentioned buses between the memories 70-76 and the processors are illustrated in FIG. 4 merely as arrowed lines. 
     Suitably, each of the processors P X , P YZ1 , P YZ2 , and P X&#39;   is of the type described in U.S. Pat. No. 4,327,355 entitled &#34;Digital Device with Interconnect Matrix&#34;, or are of the type described in co-pending application Ser. No. 087,666 entitled &#34;Digital Computer Having Programmable Structure&#34; filed Oct. 24, 1979 (now U.S. Pat. No. 4,346,438), both of which are assigned to the assignee of the present application. Also suitably, each of the memories 70-77 is of the type described in U.S. Pat. No. 4,262,298 entitled &#34;RAM Having a Stabilized Substrate Bias and Low Threshold Narrow-Width Transfer Gate&#34; which again is assigned to the assignee of the present application. 
     Processors P X  and P X&#39;   operate during respective spaced-apart time intervals to share in the execution of each X-CODE instruction. By comparison, processors P YZ1  and P YZ2  operate in parallel between the time intervals in which processors P X  and P X&#39;   operate, and they execute respective Y-CODE and Z-CODE instructions. This operation will now be described in greater detail in conjunction with FIGS. 5A and 5B. 
     FIGS. 5A and 5B are in the form of a chart having several rows and columns. The rows represent respective time intervals and are labeled t1, t2, . . . t40. Also, four of the columns, which are labeled IP X , IP YZ1 , IP YZ2 , and IP X&#39; , indicate the low level language instructions that are respectively executed by processors P X , P YZ1 , P YZ2 , and P X , during the various time intervals. Lying adjacent to those columns are four other columns which indicate how the low level language instructions are executed. 
     In FIGS. 5A and 5B, the X-CODE, Y-CODE, and Z-CODE instructions that are listed are those which were generated during the compilation process of statement 10 in FIG. 2. Inspection of FIGS. 5A and 5B shows that processor P X  executes a portion of the compiled instruction X1 during time intervals t1-t6 while processors P X&#39;   executes the remaining portion of that same instruction during time intervals t11-t16. 
     Meanwhile, between the time intervals that processors P X  and P X&#39;  are operating on the X1 instruction, processors P YZ1  and P YZ2  are executing respective sets of Y-CODE and Z-CODE instructions. Specifically, processor P YZ1  executes instructions Y10-Y20 during time intervals t5-t15 while processor P YZ2  executes instructions Z10-Z15 during time intervals t7-t12. 
     Similarly, processor P X  executes a portion of instruction X2 during time intervals t7-t16; while processor P X&#39;  executes the remaining portion of that instruction during time intervals t24-t30. And between the time intervals that processors P X  and P X&#39;  operate on instruction X2, processors P YZ1  and P YZ2  simultaneously execute separate Y-CODE and Z-CODE instructions. Specifically, processor P YZ1  executes instructions Y40-Y48 during time intervals t17 and t25; while processor P YZ2  executes instructions Z30-Z45 during time intervals t14-t29. 
     Consider now in greater detail the sequence by which processors P X , P YZ1 , P YZ2 , and P X&#39;  execute the X-CODE, Y-CODE, and Z-CODE instructions. To begin, during time interval t1, processor P X  fetches instruction X1. Next, during time interval t2, processor P X  fetches the NAME TABLE ENTRY of the indexed variable B(J,I) that is referenced in instruction X1. Thereafter, during time interval t3, processor P X  determines that the NAME TABLE ENTRY for variable B(J,I) has a code of 11; and so processor P X  sends the corresponding NAME TABLE ENTRY address over bus 60 to processor P YZ1 . 
     During time interval t4, processor P YZ1  receives the address sent by processor P X  ; and during time interval t5, that address is loaded into a program counter. That address is of instruction Y10; and so, processor P YZ1  executes instruction Y10 during the next time interval t5. Thereafter, processor P YZ1  sequentially executes instructions Y11 through Y18 during time intervals t6-t13 to compute the address of the indexed variable B(J,I). 
     During the following time interval of t14, processor P YZ1  sends the address of the variable B(J,I) to processor P X&#39; . Then, during time interval t15, processor P YZ1  returns to a state where it is ready to receive another address from processor P X . 
     Meanwhile, back during time interval t4, processor P X  continues to execute instruction X1 by fetching the NAME TABLE ENTRY of variable C(K). Then, during time interval t5, processor P X  determines that the NAME TABLE ENTRY has the code of 11; and so it sends the corresponding NAME TABLE ENTRY address over bus 60 to processor P YZ2 . 
     That address is received by processor P YZ2  during time interval t5; and it is loaded into the processor&#39;s program counter during time interval t6. Then, during the next time interval of t7, processor P YZ2  executes the adressed instruction, which is instruction Z10. 
     Thereafter, during time intervals t8-t10, processor P YZ2  sequentially executes instructions Z11-Z13 to compute the address of the indexed variable C(K). Then, during time interval t11, processor P YZ2  sends the address of variable C(K) to processor P X&#39;  ; and during time interval t12 it returns to a state where it is ready to receive another address from processor P X . 
     Meanwhile, back during time interval t5, processor P X  completed its operations on instruction X1. So, during the next time interval t6, processor P X  transfers instruction X1 via bus 60 to processor P X&#39; . Thereafter, during time interval t7, processor P X  returns to a state where it begins execution of the next X-CODE instruction. 
     Processor P X&#39;  receives instruction X1 from processor P X  during time interval t6. But, processor P X&#39;  does not begin execution of instruction X1 until it receives an address from one of the processors P YZ1  or P YZ2 . That occurs during time interval t11 in which processor P X&#39;  receives the address of the variable C(K) from processor P YZ2 . 
     During the following time interval t12, processor P X&#39;  fetches the variable C(K) from the data memory 77; and during time interval t13 it stores the result in a temporary register R1. Then during time interval t14, processor P X&#39;  receives the address of the variable B(J,I) from processor P YZ1 . 
     In time interval t15, processor P X&#39;  fetches the variable B(J,I). Then, in the next time interval t16, processor P X&#39;  receives the variable B(J,I), adds it to the variable C(K), and stores the result in register R1. This addition operation is specified by the X1 instruction that was previously received by processor P X&#39;  from processor P X  during time interval t6. 
     The addition operation by processor P X&#39;  completes the execution of instruction X1. Consequently, during the next time interval of t17, processor P X&#39;  returns to a state where it is ready to receive another X-CODE instruction from processor P X . 
     Meanwhile, back during time interval t7, processor P X  fetches the next X-CODE instruction which is instruction X2. Then, during time interval t8, processor P X  fetches the NAME TABLE ENTRY of the variable FOX(I,J,K). Then in time interval t9, processor P X  examines the NAME TABLE ENTRY that it fetched, determines that it has a 11 code, and attempts to send the address portion of the NAME TABLE ENTRY to one of the processors P YZ1  or P YZ2 . 
     However, since both processors P YZ1  and P YZ2  are already busy computing respective addresses during time interval t9, they are not free to receive the address from processor P X . Thus, processor P X  retries during the subsequent time intervals to send the address. And, during time interval t12, processor P YZ2  completes its calculation of the address of variable C(K); and so it receives the NAME TABLE ENTRY address from processor P X . Thereafter, during time interval t13, processor P YZ2  branches to the Z-CODE instructions that compute the address of the variable FOX(I,J,K). Processor P YZ2  executes these instructions during time intervals t14-t27. Then, during time interval t28, processor P YZ2  sends the computed address to processor P X&#39;  ; and during time interval t29, processor P YZ2  returns to a state where it is ready to begin execution of another Y-CODE or Z-CODE instruction set. 
     Meanwhile, back during time interval t13, processor P X  continues the execution of instruction X2 by fetching the NAME TABLE ENTRY of the variable D(I 2  -J+3). Thereafter, during time interval t14, processor P X  determines that the fetched NAME TABLE ENTRY has an 11 code, and so it attempts to send the NAME TABLE ENTRY address to one of the processors P YZ1  or P YZ2 . 
     Neither of the processors P YZ1  or P YZ2  are free to accept the NAME TABLE ENTRY address from processor P X  during time interval t14; so, processor P X  retries the sending of the NAME TABLE ENTRY address during time interval t15. Then during time intervals t16, processor P X  sends instruction X2 to processor P X&#39;  ; and during time interval t17, processor P X  returns to a state where it begins execution of another X-CODE instruction. 
     But, during time interval t16, processor P YZ1  branches to the Y-CODE instructions at the address that it received from processor P X . Thereafter, during time intervals t17-t23, processor P YZ1  executes the Y-CODE instructions which compute the address of the variable D(J 2  -I+3). Then, during the next two time intervals, processor P YZ1  sends the computed address to processor P X&#39;  and returns to a state where it is ready to receive another address from processor P X . 
     Meanwhile, during time interval t17, processor P X&#39;  is ready to begin execution of the X2 instruction that it previously received from processor P X . So, processor P X&#39;  waits until it receives an address of a variable that is operated on in instruction X2. One of those addresses is sent by processor P YZ1  during time interval t24; and the other address is sent by processor P YZ2  during time interval t28. These addresses are then utilized by processor P X&#39;  during time intervals t25-t30 to fetch the addressed variables and perform an operation on them as indicated in the X2 instruction. 
     Back during time interval t17, processor P X  begins execution of instruction X3 by fetching that instruction. Then, during time interval t18, processor P X  fetches the NAME TABLE ENTRY for the variable EASY; and during the next time interval, processor P X  determines that the variable EASY is not indexed since the code in the NAME TABLE ENTRY is 00. 
     Thereafter, during time interval t20, processor P X  examines the second item in instruction X3 and determines that it is a constant. So, during the next time interval of t21, processor P X  finishes its operations on instruction X3 by sending it along with the address of the variable EASY to processor P X&#39; . 
     Next, during time interval t22, processor P X  begins execution of instruction X4. In time interval t23, processor P X  decodes instruction to determine that neither of the items T1 or T2 in that instruction require a fetch from the NAME TABLE. So, during time interval t24, processor P X  sends instruction X4 to processor P X&#39; . 
     Then, during time interval t25, processor P X  begins execution of instruction X5. This execution involves a fetch of the NAME TABLE ENTRY for the variable ABLE, which occurs during time interval t6. And during time interval t27, processor P X  completes its execution of instruction X5 by sending that instruction along with the NAME TABLE ENTRY of the variable ABLE to processor P X&#39; . 
     Meanwhile, during time interval t31, processor P X&#39;  begins execution of instruction X5. This execution consists of the fetching of the variable EASY during time interval t32 and adding of that variable to the constant -5 during time interval t33. 
     Next, during time interval t34, processor P X&#39;  begins execution of instruction X4. This execution involves the adding of two previously calculated intermediate results that were stored in registers R1 and R2. 
     Thereafter, during time interval t36, processor P X  begins execution of instruction X5. This execution involves combining the intermediate results in registers R1 and R3 and storing that final result in data memory 77 at the address corresponding to the variable ABLE. 
     As a variation of the above sequence, suppose that the constant instead was an indexed variable and had a code in the NAME TABLE ENTRY of 11. In that case, processor P X  would transfer the address in the NAME TABLE ENTRY to one of the processors P YZ1  or P YZ2  which in turn would compute the address of the indexed variable as described above with respect to the other indexed variables. 
     From the above description, it should be apparent that the data processing system of FIG. 4 executes the object code of FIG. 2 substantially faster than the corresponding object code of FIG. 1 could be executed. This is because the processing system of FIG. 4 executes the Y-CODE and Z-CODE instructions in parallel while at the same time interleaving the execution of the X-CODE instructions. 
     Inspection of FIG. 5 shows that processor P X  executes the object code of FIG. 2 during time intervals t1-t27. This is a total of 27 time intervals; whereas by comparison, the corresponding object code of FIG. 1 requires a total of 47 time intervals for its execution. Thus, by this comparison, an improvement of (47-27)÷27 is obtained, which is an improvement of 74 percent. 
     As another measure of the improvement, inspection of FIG. 5 shows that processor P X  executes the object code of FIG. 2 during time intervals t11-t38. This is a total of 28 time intervals. So, by this comparison, an improvement of (47-28)÷28 is obtained, which is an improvement of 69 percent. 
     Various preferred embodiments of the invention have now been described in detail. However, many modifications and changes can be made to these details without departing from the nature and spirit of the invention. Accordingly, it is to be understood that the invention is not limited to said details but is defined by the appended claims. 
     
         ______________________________________                                    
COMPUTER LISTING 1                                                        
______________________________________                                    
#FILE (MTSXXX)COMPILER ON ENGPK                                           
procedure emit --x --code(opcode, sourcel, source2, dest);                
This procedure generates the outputs the object code                      
begin                                                                     
.                                                                         
.                                                                         
end;                                                                      
procedure generate --x --code(op, operand,                                
This procedure generates X code for either a pair of                      
variables or a pair of array elements as determined by the                
parameters with which it is called. Additionally, code to                 
operate on previously generated temporary results may be                  
generated.                                                                
begin                                                                     
if old --op = empty then                                                  
               the first operand of a pair                                
begin          has just been encountered                                  
old --op : = op;                                                          
old --: = operand;                                                        
end                                                                       
else                                                                      
if temp --op = empty then                                                 
               a pair has been found, and no                              
begin          temporary results have been made                           
if old --op = op then                                                     
emit --x --code(&#34;add&#34;, old --operand, operand, temp1)                     
else                                                                      
emit --x --code(&#34;subtract&#34;, old --operand, operand, temp1);               
temp -- : = op;                                                           
old --op: = empty;                                                        
end                                                                       
else begin % there is a pair, and a previously generated                  
temporary                                                                 
if old --op = op then                                                     
emit --x --code(&#34;add&#34;, old --operand, temp2)                              
else                                                                      
emit --x --code(&#34;subtract&#34;, old --operand, operand, temp2);               
if temp --op = op then                                                    
emit --x --code(&#34;add&#34;, temp1, temp2, temp1)                               
else                                                                      
emit --x --code(&#34;subtract&#34;, temp1, temp2, temp1);                         
temp --op : = op;                                                         
old --op : = empty;                                                       
end;                                                                      
end generate --x --code;                                                  
repeat                                                                    
begin                                                                     
read(input, input --data);                                                
if not eof(input) then                                                    
begin                                                                     
initialize --scanner(input --data);                                       
scan --next --token;                                                      
while token &lt;&gt; end --of --statement do                                    
begin                                                                     
if identifier(token) then                                                 
begin                                                                     
if not present --in --symbol --table(token) then                          
begin                                                                     
ste : = new --symbol  --table --entry;                                    
id(ste) : = token;                                                        
nte : = new --name --table --entry;                                       
name(ste) : = nte;                                                        
scan --next --token;                                                      
if token = &#34;(&#34; then                                                       
begin                                                                     
scan --next --token;                                                      
type(ste) : = array;                                                      
code(nte) : = &#34;11&#34;;                                                       
address(nte) : = generate --y --z --code;                                 
if token &lt;&gt; &#34;)&#34; then                                                      
error;                                                                    
scan --next --token;                                                      
end                                                                       
else begin                                                                
type(ste) : = simple --variable;                                          
code(nte) : = &#34;00&#34;;                                                       
address(nte) : = assign --address --for --variable;                       
end;                                                                      
end                                                                       
else begin                                                                
ste : =  --table repeat lookup(token);                                    
if type(ste) = array then                                                 
begin                                                                     
scan --next --token;                                                      
if token &lt;&gt; &#34;(&#34; then                                                      
error                                                                     
else begin                                                                
scan --next --token;                                                      
nte : = new --name &#39;table --entry;                                        
code(nte) : = &#34;11&#34;;                                                       
address(nte) : = generate --y --and --z --code;                           
compare --array  --ntes(ste, nte);                                        
if token &lt;&gt; &#34;)&#34; then                                                      
error;                                                                    
scan --next --token;                                                      
end;                                                                      
end;                                                                      
end;                                                                      
end                                                                       
else begin                                                                
scan --next --token;                                                      
end;                                                                      
end,                                                                      
initialize --scanner(input --data);                                       
scan --next --token;                                                      
if not identifier(token) then                                             
error                                                                     
else begin                                                                
ste : = symbol --table --lookup(token);                                   
if type(ste) = array then                                                 
begin                                                                     
scan --next --token;                                                      
if token &lt;&gt; &#34;(&#34; then                                                      
error;                                                                    
dest --name : = find name;                                                
if token &lt;&gt; &#34;)&#34; then                                                      
error;                                                                    
end                                                                       
else                                                                      
dest --name : = name(dest);                                               
scan --next --token;                                                      
if token &lt;&gt; &#34;=&#34; then                                                      
error;                                                                    
if operator(token) then                                                   
begin                                                                     
op : = token;                                                             
scan --next --token;                                                      
end                                                                       
else                                                                      
op : = &#34;+ &#34;,                                                              
array --op : = empty;                                                     
var --op := empty;                                                        
temp --: = empty;                                                         
repeat                                                                    
begin                                                                     
if identifier(token) then                                                 
begin                                                                     
ste : = symbol --table --lookup(token);                                   
if type(ste) = array then                                                 
begin                                                                     
scan --next --token;                                                      
if token &lt;&gt; &#34;(&#34; then                                                      
error;                                                                    
operand --name : = find --name;                                           
if token &lt;&gt; &#34;)&#34; then                                                      
error;                                                                    
generate --x --code(op, operand,                                          
array --op, array --operand, temp --op);                                  
end                                                                       
else                                                                      
if type(ste) = variable then                                              
begin                                                                     
operand : = name(ste);                                                    
scan --next --token;                                                      
generate --x --code(op, operand,                                          
var --op, var --operand, temp --op);                                      
end;                                                                      
end                                                                       
else                                                                      
if number(token) then                                                     
begin                                                                     
operand : = value(token);                                                 
scan --next --token;                                                      
generate --x --code(op, operand,                                          
var --op, var --operand, temp -- op);                                     
end                                                                       
else                                                                      
error;                                                                    
if operator(token) then                                                   
begin                                                                     
op : = token;                                                             
scan --next --token;                                                      
if token = end --of --statement then                                      
error;                                                                    
end;                                                                      
end                                                                       
until token = end --of --statement,                                       
end;                                                                      
end;                                                                      
end                                                                       
until eof(input);                                                         
end.                                                                      
#                                                                         
______________________________________