Method of generating code for programmable processor, code generator and application thereof

<u>Field of Invention</u>

0001The present invention relates to computer compilers. More particularly, the invention relates to a compiler that incorporates a code generator to generate code for programmable processors and wherein a graph based representation of said programmable processors is included.

<u>Background of the Invention</u>

0002Designers of electronic systems, as for example, consumer electronics, communication systems and multimedia related electronic systems, more and more incorporate a programmable processor in said systems. Programmability offers the possibility of a cost-effective hardware reuse and the flexibility to support last minute specification changes or to add new features to said systems.

0003A code generator and an instruction set simulator are the key tools to aid the designer in designing the programmable processors of said systems and in developing the software to program said processors. The effort to develop said tools should be as small as possible. Ideally, these tools should be reusable for every new programmable processor without modification. Therefore, they should be retargetable. A retargetable code generator has the extra advantage that late instruction-set changes are supported. It also aids in the design of the programmable processors by providing quality measures (code size, execution time, resource utilization, and the like) on the mapping of applications to different hardware variations.

0004Code generators have different specific tasks to fulfill of which the most important ones are code selection, register allocation and scheduling. Each of these tasks is implemented in a different program called a code generator phase which works on a different view of the processor. Processor models for existing code generators are just a set of these different views.

0005It is to be noted that the requirements of programmability, low cost and low power have resulted in a new class of application specific instruction set processors (ASIPs). These are a hybrid form of custom architectures and standard processors, offering an instruction set and hardware implementation which are optimized for a small number of applications. Because of the small number of applications to be mapped on an ASIP, it is of importance to have retargetable code generators for this class of programmable processors.

0006In the following paragraphs prior art processor models and descriptions that are used in code generation and in retargetable code generation for different types of processors are reviewed.

0007The first retargetable code generators were designed for complex instruction set computers (CISCs). The architecture of these computers contains instructions with complicated operation patterns. Code selection was the most important task in these code generators and it performed register allocation and scheduling as a by-product. Code selection was implemented as tree pattern matching. As a consequence, the processor descriptions were tree or string grammars in which the production rules directly model the operation patterns available in the instruction set (Glanville and Graham, "A new method for compiler code generation", <u>Proc. 5th Ann. ACM SYMP. on Princ. of Prog. Lang</u>., pages 231-240, 1978; Aho and Tjiang, "Code-generation using tree matching and dynamic programming", <u>ACM Trans. on Prog. Languages and Systems</u>, Vol. 11, No. 4, pages 491-516, 1989). Some descriptions were more complicated and contained matching preconditions related to hardware peculiarities, data types, storage locations and addressing modes.

0008In other approaches, a machine description is an enumeration of all instructions along with their corresponding simple register transfers. Also, the application is transformed in these register transfers. Code selection is performed by combining register transfers in the application into groups to be performed by one instruction (Davidson and Fraser, "The design and application of a retargetable peephole optimizer", <u>ACM Trans. on Prog. Languages and Systems</u>, Vol. 2, No. 2, pages 191-202, 1980).

0009More recent code generators have been developed for reduced instruction set computers (RISCs). In this case, the register allocation and scheduling tasks are more important than code selection and also need their specific information. For example, the processor description of the Marion retargetable code generator for RISCs (Bradlee, "Retargetable instruction scheduling for pipelined processors", Ph.D thesis at the University of Washington, 1991) contains a declaration of storage elements and other resources in addition to the instruction set enumeration. The register transfers are then annotated with scheduling and resource utilization information.

0010Recent retargetable code generators for ASIPs (Paulin, et al., "DSP tool requirements for embedded systems: a telecommunications industrial perspective", <u>J. VLSI Signal Processing</u>, Vol. 9, No. 1, 1995; Fauth and Knoll, "Automated generation of DSP program development tools using a machine description formalism", <u>Proc. IEEE of ICASSP 93</u>, Minneapolis, 1993) also use different views of a processor.

0011Retargeting the above mentioned code generators to a new processor involves rewriting all the code generator phase specific views of the processor. This is a large effort especially because all views must be kept consistent. To solve this problem, some (e.g. Fauth and Knoll) try to derive the models from one processor description language (nML). This approach needs an analysis program for each model which is still a lot of work to implement.

0012In code generators of prior art, the code generator phases use different models each containing a different view of the processor. This makes it difficult to have them work closely together.

0013A. Fauth, et al. furthermore teach in "Describing instruction set processors using nML", <u>Proc. European Design Test Conference</u>, Paris, France, 1995, the use of the nML formalism to describe processors in terms of their instruction set. Situated at the level of description that is found in programmer's manuals, nML allows for concise specifications of programmable instruction set processors.

0014Some retargetable code generators already introduced a graph processor model. These graph models however do not contain sufficient information for all phases in a code generator. Mueller (Mueller and Varghese, "Flow graph machine models in microcode synthesis", <u>Proc. 6th Ann. Workshop on Microprog.</u>, pages 159-167, 1983) used a graph model for performing the task of code selection by symbolic execution. For the processors he targeted, a by-product of this code selection was register allocation. Scheduling was performed separately using a different view of the processor. Nowak (Nowak and Marwedel, "Verification of hardware descriptions by retargetable code generation", <u>26th ACM/IEEE Design Automation Conference</u>, 1989) extracts a so-called connection-operation graph from a structural processor description. The description is a detailed netlist of the processor including the controller and the instruction decoder, but this is often not available to the software developer. The connection-operation graph maps all conflicts on the instruction word and does not support additional checks for hardware conflicts. As a consequence, bus conflicts must be treated separately. The model only supports single-cycle operations.

0015J.Van Praet, et al. discloses in "Instruction set definition and instruction selection for ASIPs", presented at the Int. Symposium on High Level Synthesis, Ontario, Canada, May 18-20, 1994, <u>Proc. IEEE of 1994</u> how instruction selection for ASIPs can be done by generating a combined instruction set and data-path model from the instruction set and an abstract data-path description, and by performing operation bundling on that model. The same disadvantages as identified for the graph models of Nowak and Mueller apply for this method.

<u>Summary of the Invention</u>

0016One aspect of the present invention is to disclose a method for generating code on a programmable processor using a graph based instruction set processor representation which models a processor with essentially all peculiarities of the architecture and the instruction set. The model, a directed bipartite graph, can be used in all code generator phases and thus eliminates the need for different phase specific machine descriptions such as, for example, an exhaustive enumeration of operation patterns for code selection or a listing of register classes for register allocation. All code generation phases find the information they need in the model without any analysis. The model can also be used in an instruction set simulator. This method based on a directed bipartite graph model is not only applicable to ASIPs but also to general purpose processors.

0017Phases in a code generator cooperate better when working on one global and complete model of the processor because of better consistency, verifiability and efficiency.

0018A processor model for retargetable code generation and instruction simulation must contain all information about the processor needed to generate correct efficient code and to simulate the content of every storage element during program execution in an instruction cycle accurate way. It must allow code generation phases to find out what operations and storage elements are available in the instruction set and how they are interconnected. Code generation and simulation programs must also contain information about all possible conflicts in a processor such as encoding restrictions and hardware conflicts. In short, the model must support efficient searches for valid patterns that translate into valid register transfers on the processor (which are enabled by a partial instruction). Also the timing and behavior of operations must be easily accessible.

0019The processor model should not, however, contain unnecessary details nor predicates to guide the code generator phases or the simulator. Not needed are, for example, the details of the decoding tables, precise timing on the sub-phases of the clock and exact modelling of hardware of which the behavior does not introduce any conflicts.

0020If the required information for executing the code generation phases and for simulating the execution of code is contained in the processor model, retargeting the code generator or simulator consists of providing the generator or the simulator with a new processor model. If the model is sufficiently abstract (i.e., it does not contain phase-specific information), this is a relatively small effort.

0021The processor model, a directed bipartite graph, advantageously can also be used in a method for synthesizing hardware that implements the processor described by said model. Said method for synthesizing the hardware comprises the step of deriving from said instruction set graph a netlist containing hardware building blocks and implementing said processor as a hardware device according to said netlist.

0022According to another aspect of the present invention, a method of generating code for a programmable processor is disclosed. Said method comprising the steps of: <ul id="ul0001" list-style="dash" compact="compact"><li>representing said processor as a directed bipartite graph with first and second sets of vertices and with edges, said graph comprising essentially all information about the instruction set and the hardware of the processor, said first set of vertices representing storage elements in said processor, and said second set of vertices representing operations in said processor,</li><li>linking said graph to tools and libraries required for generating code for said processor, and</li><li>executing the required code generation phases whereby the required information about said processor is extracted from said graph.</li></ul>

0023An operation is defined as a primitive processor activity. The operations are annotated with their enabling conditions representing the values of the instruction word that activate them.

0024In this method, said edges represent valid connections between said operations and said storage elements, said connections modelling the data flow in said processor.

0025According to one preferred embodiment of the present invention, this method can be adapted for evaluating the optimization phase of generating code for an application algorithm and therefore it further comprises the step of building a decision tree with vertices and branches wherein: <ul id="ul0002" list-style="dash" compact="compact"><li>vertices of said decision tree represent primitive operations, whereby said application algorithm contains instances of said primitive operations;</li><li>said branches represent possible transformations of said primitive operations according to alternative mapping possibilities in said optimization space, and</li><li>wherein, the set of vertices of said decision tree comprises vertices representing patterns of other vertices of said set, said pattens being defined during said code generation phases, and said second set of vertices representing operations of said processor.</li></ul>

0026According to another preferred embodiment, this method can furthermore comprise the steps of: <ul id="ul0003" list-style="dash" compact="compact"><li>representing hardware conflicts in said processor as access conflicts on said vertices representing said storage elements; and</li><li>annotating each vertex of said second set of vertices representing operations with their enabling condition, said enabling condition representing values in the instruction register of said processor that enable the execution of the operation represented by said vertex.</li></ul>

0027If said method determines valid partial instructions, it further comprises the steps of: <ul id="ul0004" list-style="dash" compact="compact"><li>selecting a subset of said second set of vertices representing operations;</li><li>verifying that the intersection of the enabling conditions of all operations of said subset is not empty; and</li><li>verifying that said subset is free of access conflicts on said storage elements.</li></ul>

0028By checking the enabling conditions and hardware conflicts, the code generator can search for valid operation patterns in the instruction set graph. Valid operation patterns are patterns without conflicts.

0029Said storage elements can be static and transitory elements. In this case, the method according to the present invention further comprises the steps of representing all hardware conflicts in said processor as access conflicts on said vertices representing said transitory storage elements.

0030The method can also be adapted to specify data-types supported by a storage element, said method further comprising the steps of: <ul id="ul0005" list-style="dash" compact="compact"><li>specifying different vertices representing one storage element;</li><li>annotating each of said different vertices with a data type supported by said one storage element, and</li><li>specifying an alias relationship between said different vertices representing said one storage element.</li></ul>

0031The method can also be adapted for representing record storage elements, said method further comprising the steps of: <ul id="ul0006" list-style="dash" compact="compact"><li>specifying a vertex representing the concatenation of several storage elements;</li><li>annotating said vertex with a data type being a record of the data types of said storage elements;</li><li>specifying a structural relationship between said vertex and the vertices representing said storage elements.</li></ul>

0032The method as defined is adapted for representing operations of which the execution depends on a defined condition, said method further comprising the steps of: <ul id="ul0007" list-style="dash" compact="compact"><li>specifying a subset of said second set of vertices representing operations, characterized in that all vertices in said subset depend on said condition;</li><li>specifying in said subset a vertex that is connected by an incoming edge to a vertex of said first set of vertices that represents the storage element where said condition is available;</li><li>specifying that said operations represented in said subset can only be enabled when said condition has a specific value.</li></ul>

0033The execution times of operation are modelled, said method further comprising the steps of : <ul id="ul0008" list-style="dash" compact="compact"><li>annotating an enabling condition of said operation with the relative time step of the corresponding instruction issue with respect to the start of said operation; and</li><li>annotating said operation with the time steps relative to the start of said operation at which said operation accesses the input and output storage elements of said operation.</li></ul>

0034If the method represents a functional unit in said processor, it further comprises the steps of specifying a subset of said second set of vertices representing operations, all vertices in said subset executing one functional unit.

0035Said processor includes a controller unit, operations modelling said controller unit are represented as vertices of said second set of vertices representing operations.

0036The present invention furthermore discloses a retargetable code generator as an executable computer program on a computer for generating code for programmable processors comprising: <ul id="ul0009" list-style="dash" compact="compact"><li>tools to build a directed bipartite graph with vertices and edges which internally represents said programmable processor, said graph comprising essentially all information about the instruction set and the hardware of said processor having first and second set of vertices, said first set of vertices representing storage elements in said processor, and said second set of vertices representing operations in said processor.</li><li>tools and libraries required to generate code for said processor, and</li><li>means to link said graph to said tools and said libraries, whereby the information about said processor requested during code generation is extracted from said graph.</li></ul>

0037The present invention furthermore discloses a method of constructing a code generator for a programmable processor comprising the steps of: <ul id="ul0010" list-style="dash" compact="compact"><li>representing said processor as a directed bipartite graph with first and second sets of vertices and with edges, said graph comprising essentially all information about the instruction set and the hardware of the processor, said first set of vertices representing storage elements in said processor, and said second set of vertices representing operations in said processor,</li><li>linking said graph to tools and libraries required for generating code for said processor, and</li><li>executing the required code generation phases whereby the required information about said processor is extracted from said graph.</li></ul>

0038In another embodiment, this method of constructing a code generator can further comprise the steps of: <ul id="ul0011" list-style="dash" compact="compact"><li>representing hardware conflicts in said processor as access conflicts on said vertices representing said storage elements; and</li><li>annotating each vertex of said second set of vertices representing operations with their enabling condition, said enabling condition representing values of the instruction register of said processor that enable the execution of the operation represented by said vertex.</li></ul>

0039Said method determines valid partial instructions, and further comprises the steps of: <ul id="ul0012" list-style="dash" compact="compact"><li>selecting a subset of said second set of vertices representing operations;</li><li>verifying that the intersection of the enabling conditions of all operations of said subset is not empty; and</li><li>verifying that said subset is free of access conflicts on said storage elements.</li></ul>

0040The present invention is also related to a method of simulating the execution of code on a programmable processor which comprises the steps of: <ul id="ul0013" list-style="dash" compact="compact"><li>representing said processor as a directed bipartite graph with first and second sets of vertices and with edges, said graph comprising essentially all information about the intruction set and the hardware of said processor, said first set of vertices representing storage elements in said processor, and said second set of vertices representing operations in said processor, said edges representing valid connections between operations and said storage elements, and said connections modelling the data flow in said processor;</li><li>linking said graph to tools and libraries required for said simulation, and</li><li>executing said simulation whereby the required information about said processor is extracted from said graph.</li></ul>

0041Furthermore, a retargetable simulator is disclosed as an executable computer program on a computer for simulating the execution of code on a programmable processor comprising: <ul id="ul0014" list-style="dash" compact="compact"><li>a tool to build an internal representation of a directed bipartite graph which represents said programmable processor with first and second sets of vertices and with edges, said graph comprising information about the instruction set and the hardware of said processor, said first set of vertices representing storage elements in said processor, and said second set of vertices representing operations in said processor;</li><li>tools and libraries required for simulating said processor, and</li><li>means to link said group of said tools and libraries whereby the information about said processor requested during simulation is extracted from said graph.</li></ul>

0042Furthermore, a method of synthesizing a programmable processor is disclosed which comprises the steps of: <ul id="ul0015" list-style="dash" compact="compact"><li>representing said processor as a directed bipartite graph with first and second set of vertices and with edges, said graph comprising information about the instruction set and the hardware of said processor;</li><li>linking said graph to tools and libraries required for generating a netlist of hardware building blocks;</li><li>implementing said processor as a hardware device according to said netlist.</li></ul>

<u>Brief Descriptions of the Drawings</u>

0043The present invention will be described below in connection with accompanying drawings figures in which: <dl id="dl0001" compact="compact"><dt><b>Figure 1</b></dt><dd>shows the data path of a small example processor.</dd><dt><b>Figure 2</b></dt><dd>represents a schematic overview of the instruction set for the example processor.</dd><dt><b>Figure 3</b></dt><dd>illustrates the instruction set graph for the (partial) instructions using the ALU in the example processor.</dd><dt><b>Figure 4</b></dt><dd>represents different ways of controlling a multicycle multiply-accumulate, modelled in the ISG: (a) non-pipelined; (b) pipelined, data-stationary controlled, and (c) pipelined, time stationary controlled.</dd><dt><b>Figure 5</b></dt><dd>illustrates the type hierarchy in the operation type library L. The gray plane "P" represents the ISG.</dd><dt><b>Figure 6</b></dt><dd>represents different kinds of data dependencies in the DFG: (a) direct data dependency; (b) direct data dependency with move operation; (c) allocated data dependecy.</dd><dt><b>Figure 7</b></dt><dd>shows an if-then-else construct in C and its corresponding CDFG in part (a); part (b) shows a small ISG to map the C program of part (a).</dd><dt><b>Figure 8</b></dt><dd>shows a conditional operation in C and its corresponding CDFG in part (a); part (b) shows a small ISG to map the C program of (a).</dd><dt><b>Figure 9</b></dt><dd>illustrates the modelling of residually controlled operations in the ISG.</dd><dt><b>Figure 10</b></dt><dd>represents two different ways of handling data type information in the ISG.</dd><dt><b>Figure 11</b></dt><dd>depicts the hierarchy which is present in the nML description of the example processor.</dd><dt><b>Figure 12</b></dt><dd>illustrates the flow diagram of a retargetable compiler.</dd><dt><b>Figure 13</b></dt><dd>represents the flow diagram of a retargetable simulator generator.</dd><dt><b>Figure 14</b></dt><dd>represents the flow diagram of an nML to ISG translator.</dd><dt><b>Figure 15</b></dt><dd>depicts the information structure diagram of the preferred embodiment of the ISG model.</dd></dl>

<u>Detailed Descriptions of Preferred Embodiments</u>

0044A processor model for retargetable code generation and instruction simulation must contain all information about the processor needed to generate correct efficient code and to simulate the content of every storage element during program execution in an instruction cycle accurate way. It must allow code generation phases to find out what operations and storage elements are available in the instruction set and how they are interconnected. Code generation and simulation programs must also contain information about all possible conflicts in a processor such as encoding restrictions and hardware conflicts. In short, the model must support efficient searches for valid patterns that translate into valid register transfers on the processor (which are enabled by a partial instruction). Also the timing and behavior of operations must be easily accessible.

0045The processor model should not, however, contain unnecessary details nor predicates to guide the code generator phases or the simulator. Not needed are, for example, the details of the decoding tables, precise timing on the sub-phases of the clock and exact modelling of hardware of which the behavior does not introduce any conflicts.

An example processor

0046A small example processor will be used to illustrate the concepts of the instruction graph model of the present invention. This processor is derived from a commercial processor for digital signal processing, namely the ADSP-2111 from Analog Devices. It should be understood, however, that the present invention is in no way restricted to this processor. The method is applicable to other commercial processors as well, and the method has already been applied to different ASIPs.

0047The data path (shown in figure 1) contains an ALU-SHIFT unit, consisting of an ALU connected through a pipeline register C to a shifter (SHIFT), and a multiply accumulate unit (MULT and A/S, with pipeline register F). Both units have their own input registers (AX,AY;MX,MY, respectively) and result registers (AR;MR1,MRO, respectively), and communicate with each other via the result bus R. The processor has a load/store architecture and can fetch two operands at a time by using both the program bus (P) and the data bus (D).

0048The instruction set is outlined in figure 2 and comprises three formats. The instruction word length is 18 bits (bits are numbered from 0 to 17, with 0 being the most significant bit). In the table, only format bits are shown. The first format, which deals with instructions incorporating an arithmetic operation with one or two indirectly addressed data moves in parallel, is detailed. One can see that the encoding excludes the parallel operation of the two arithmetic parts in the data path. The second format encodes data moves with direct addressing and the third one contains all control flow instructions.

<u>1. A BIPARTITE GRAPH AS A PROCESSOR MODEL</u>

0049The instruction set graph (ISG) for the present invention is designed in accordance with the above requirements. It is a directed bipartite graph G_ISG (V_ISG,E_ISG) with V_ISG = V_S ∪ V_I, where V_S contains vertices representing storage elements in the processor and V_I contains vertices representing its operations. The edges in V_ISG ⊂ (V_S x V_I) ∪ (V_I x V_S) represent the connectivity of the processor and model data flow from storage, through ISG operations, to storage. Figure 3 contains a part of the ISG for the example processor; the details of this figure will be explained below.

<u>ISG operations</u>

.

0050ISG operations are primitive processor activities transforming values in storage elements into other values in other storage elements.

0051In each instruction, the processor executes a number of operations. Conversely, a certain operation can be enabled by several instructions. The set of instructions that enables an operation i in the ISG is called its enabling condition and denoted by <b>enabling</b>(<i>i</i>). It is currently assumed that the binary encoding of instructions is available to be used in the enabling conditions. However, the enabling conditions could also be defined in a more abstract way, using assembler-like symbols (mnemonics) for instruction parts. In Figure 3, the enabling conditions are shown in a binary cubic representation, with "x" meaning "don't care". A subset of ISG operations V_Io ⊂ V_I is said to have an encoding conflict when ∩_i∈VIo<b>enabling</b>(<i>i</i>) = Φ. The intersection of enabling conditions ∩_i∈VIo<b>enabling</b>(<i>i</i>) is the enabling condition for the set V_Io, which is empty in the case of an encoding conflict. A multiplexer is for example modelled as a set of <b>copy</b> operations having a common output storage element such that all pairs of <b>copy</b> operations have encoding conflicts.

<u>Storage</u>

0052In the ISG, a distinction is made between two kinds of storage elements. See, for example Landskov, Davidson et al., "Local microcompaction techniques", <u>ACM computing surveys</u>, 12(3)261-294, 1980. In particular, the two kinds of storage elements are defined as follows : <ul id="ul0016" list-style="none" compact="compact"><li>1. <b><i>Static</i></b> storage holds its value until explicitly overwritten. The same value can be read several times. A static storage element has a certain capacity of values it can contain at the same time (e.g. the number of fields in a register file). Static storage consists of memory and controllable registers, respectively denoted by the sets V_M and V_R.</li><li><i>2.</i><b><i>Transitory</i></b> storage passes a value from input to output with a certain delay. A transitory storage element will simply be called a transitory. A transitory can only contain one value at a time. Examples are buses and wires, which have zero delay, and pipeline registers which have a non-zero delay. Transitories form the set V_T.</li></ul>

0053Together, the storage elements define a <i><b>structural skeleton</b></i> of the target machine (V_S = V_M ∪ V_R ∪ V_T). In Figure 3, storage elements are depicted as small rectangular boxes, each having a label denoting their data type between parentheses. In the example the data type is named <b>num</b> and is an additional interpretation of a bit string of length 16. The storage elements at the top and bottom are registers, all others are transitories.

0054A code generator must not only check for encoding restrictions between operations, but also for <i>hardware conflicts</i> (or structural hazards), which are not always prevented by the encoding conflicts. For example, hardware conflicts can occur between operations of orthogonal instruction fields. Such instructions are called "illegal" instructions. In the case of pipelined processors, hardware conflicts can even occur between operations of different instructions and timing profiles must be taken into account. An interesting feature of transitories is that they are used to model hardware conflicts in code generation.

0055A hardware conflict is represented as an access conflict on a transitory. The code generator will avoid access conflicts on transitories, by allowing at most one operation to write to each transitory in each machine cycle. To illustrate the modelling of hardware conflicts, two examples will be considered : <ul id="ul0017" list-style="dash" compact="compact"><li>Different tristate drivers can be connected to the same bus and are not allowed to write to it during the same cycle, even not when an instruction encoding allows it. To prevent the code generator from generating such an instruction, the bus is modelled as a transitory and the tristate drivers as <b>copy</b> operations. The conflict then turns into an access conflict on the transitory (i.e. a bus conflict) which can be checked and avoided by the code generator. This resembles the way a multiplexer is modelled in the ISG, but in the case of a bus conflict the enabling conditions of the <b>copy</b> operations are not exclusive. Remark that in the ISG of Figure 3 the result bus has not been modelled explicitly (it is merged with the multiplexer) because no result bus conflicts occur with the example instruction set.</li><li>Read/write ports of static storage are also modelled as transitories in order to make the code generator check for <b><i>port conflicts</i></b><i>.</i> Port conflicts occur when two operations try to access a storage element via the same port in the same cycle.</li></ul>

0056In summary, memory and register nodes are included in the ISG as they are present in the architecture. Transitories on the other hand, are not necessarily uniquely related to physical interconnect resources in the architecture. An operation may for example encapsulate a physical interconnection, or a transitory may be needed to connect the parts of an operation that is artificially split. It is however crucial that the correct processor behaviour is represented, including the hardware conflicts.

<u>Timing</u>

0057A multi-cycle instruction may activate operations some cycles after the instruction issue. Therefore an enabling condition is annotated with the relative time step of the instruction issue with respect to the start of the operation. The term <b><i>operation stage</i></b> will be used to denote a time step relative to the (execution) start of an operation. For example, operation stage 0 and 1 are respectively the first and second step in which the corresponding operation is active, and stage -1 is the last time step <b><i>before</i></b> the operation becomes active. Each operation is also annotated with the operation stage at which it accesses its input and output storage elements.

0058The operations and instructions in the previously discussed example processor are all single-cycle, so the operation timing is omitted in Figure 3, but it is annotated in Figure 4 for some fictitious examples. Operation stages are shown between parenthesis, as annotations of enabling conditions and of input and output arguments of ISG operations. Figure 4(a) shows how a two-cycle, non-pipelined multiply-accumulate operation would look like in the ISG, assuming that it needs its input and output storage elements during both cycles.

0059In data-stationary code, one instruction controls all operations that are executed on a data item as it is traversing the pipeline (P.M. Kogge, "The Architecture of Pipelined Computers", <u>Advanced Computer Science Series</u>, McGraw-Hill Book Company, 1981).

0060A data-stationary instruction that controls a two-cycle multiply-accumulate pipeline, is modelled by two ISG operations, as shown in Figure 4(b). The operations are connected by a transitory with a delay of one cycle and each of them is annotated with operation stages. The code generator can then easily derive the timing of the complete pattern and replace the pattern by a more abstract operation, as will be explained in the sequel.

0061If the same multiply-accumulate pipeline is time-stationary controlled, it is modelled as in Figure 4(c). In time-stationary code, one instruction controls all operations that are executed during one cycle, possibly on several sets of data (P.M. Kogge, "The Architecture of Pipelined Computers", <u>Advanced Computer Science Series</u>, McGraw-Hill Book Company, 1981).

0062To allow the code generator to also replace this operation pattern by an abstract operation, multi-cycle operations are allowed to have multiple enabling conditions, for example one for each cycle.

<u>2. CODE GENERATION USING THE ISG MODEL.</u>

0063In this section it will be explained how the ISG processor model is used to generate code for the execution of a given algorithm on a given processor. In the sequel an overview of a retargetable compiler, using the preferred embodiment of the present invention, is given by means of a flow diagram. The implementation of the ISG is also discussed in the sequel.

0064The algorithm to be mapped on the processor is given as a data flow graph (DFG) which also takes the form of a bipartite graph G_DFG (V_DFG,E_DFG), where V_DFG = V_O ∪ V_V with V_O representing the operations and V_V representing the values they produce and consume. The edges in E_DFG ⊂ (V_O x V_V) ∪ (V_V x V_O) represent the data flow. Code generation then consists in finding a mapping of G_DFG (V_DFG,E_DFG) onto G_ISG (V_ISG,E_ISG) with values in V_V mapped on storage elements in V_S and the DFG operations of V₀ on corresponding ISG operations of V_I.

0065The code generation task is split in subsequent phases. First, during the code selection phase, it is decided on which values will be bound to transitories. A data dependency of which the corresponding value is bound to a transitory, results in a fixed timing constraint because of the delay of the transitory. This timing constraint may not produce a conflict between the involved DFG operations, otherwise it can not be satisfied and the value must be bound to a static storage element. Conflict free DFG operations with fixed timing constraints are grouped, and each implementation of such a group is called a <b><i>bundle</i></b><i>.</i> After this, during the register allocation phase, the remaining values are bound to static storage elements and the DFG is completed with the necessary data transfers. Finally, during the scheduling phase, the bundles are bound to time. Below, more details are given on how the DFG is bound to the ISG.

<u>Refinement</u>

0066To represent the different ways in which a DFG operation can be mapped on the ISG, an operation type hierarchy is used. Figure 5 shows an example of this hierarchy for a subtraction, where four implementations exist for the abstract <b>sub</b> operation type. Each implementation is a subtype of an abstract operation type, for example, <b>subXY</b> is a subtype of <b>sub</b>. The abstract operations and the operations in the ISG form a library L of primitive operations of which DFG operations are instances. Each DFG operation is an instance of an operation type in <i>L :</i><maths id="math0001" num=""><math display="block"><mrow><mtext mathvariant="italic">∀o</mtext><msub><mrow><mtext> ∈ V</mtext></mrow><mrow><mtext>O</mtext></mrow></msub><mtext>, ∃ </mtext><mtext mathvariant="italic">l</mtext><mtext> ∈ </mtext><mtext mathvariant="italic">L :</mtext><mtext> type(</mtext><mtext mathvariant="italic">o</mtext><mtext>) = </mtext><mtext mathvariant="italic">l.</mtext></mrow></math><img file="EP0743599A2_D0001.tif" /></maths>

0067In fact, the library <i>L</i> is a decision tree with vertices and branches which is used in the mapping of a DFG to the ISG. Vertices correspond to primitive operations, and branches represent possible refinements of primitive operations according to alternative mapping possibilities in the optimisation space. As shown by the example in Figure 5, where the ISG is the gray plane labelled "P", the ISG is thus completely integrated with the library.

0068During code generation, DFG operations are refined until they are instances of ISG operations, so they can be executed by the processor. Each operation<maths id="math0002" num=""><math display="block"><mrow><mtext mathvariant="italic">o</mtext><msub><mrow><mtext> ∈ V</mtext></mrow><mrow><mtext>O</mtext></mrow></msub><mtext> : type(</mtext><mtext mathvariant="italic">o</mtext><mtext>) ∈ </mtext><mtext mathvariant="italic">L</mtext></mrow></math><img file="EP0743599A2_D0002.tif" /></maths> is replaced by a refined operation <i>r</i> such that :<maths id="math0003" num="(1)"><math display="block"><mrow><mtext>type(</mtext><mtext mathvariant="italic">r</mtext><mtext>) = </mtext><mtext mathvariant="italic">i</mtext><mtext> ∧ </mtext><mtext mathvariant="italic">i</mtext><msub><mrow><mtext> ∈ V</mtext></mrow><mrow><mtext>I</mtext></mrow></msub><mtext> ∧ </mtext><mtext mathvariant="italic">i</mtext><mtext> is a subtype of type(</mtext><mtext mathvariant="italic">o</mtext><mtext>)</mtext></mrow></math><img file="EP0743599A2_D0003.tif" /></maths>

<u>Binding data dependencies</u>

0069Consider a data dependency between two refined DFG operations <i>r</i>₁ and <i>r</i>₂, with corresponding value_<i>1</i><i>v</i>_V ∈ V. Assume that the DFG operations are bound by the code generator to the ISG operations :<maths id="math0004" num=""><math display="block"><mrow><msub><mrow><mtext mathvariant="italic">i</mtext></mrow><mrow><mtext>1</mtext></mrow></msub><mtext> = type(</mtext><msub><mrow><mtext mathvariant="italic">r</mtext></mrow><mrow><mtext>1</mtext></mrow></msub><mtext>) and </mtext><msub><mrow><mtext mathvariant="italic">i</mtext></mrow><mrow><mtext>2</mtext></mrow></msub><mtext> = type(</mtext><msub><mrow><mtext mathvariant="italic">r</mtext></mrow><mrow><mtext>2</mtext></mrow></msub><mtext>).</mtext></mrow></math><img file="EP0743599A2_D0004.tif" /></maths>

0070The function <b>output</b>(<i>i</i>, <i>n, s)</i> returns the storage element on which <i>i</i> writes its <i>n</i>-th output during operation stage <i>s</i> and the function <b>input</b>(<i>i</i>, <i>n, s</i>) returns the storage element from which <i>i</i> reads its <i>n</i>-th input during operation stage <i>s</i>.

0071To simplify the notation, it is assumed in the following that the respective integers <i>n</i> and <i>s</i> are chosen according to the data dependency under consideration.

0072The code generator has different alternatives to bind a data dependency to the ISG. If a data dependency is bound to a path in the ISG that does not include a static storage element, it will result in a fixed time constraint between the involved DFG operations. It is therefore called a direct data dependency. Figure 6(a) shows the binding of a data dependency where :<maths id="math0005" num=""><math display="block"><mrow><mtext>output(</mtext><msub><mrow><mtext mathvariant="italic">i</mtext></mrow><mrow><mtext mathvariant="italic">1</mtext></mrow></msub><mtext>, </mtext><mtext mathvariant="italic">n, s</mtext><mtext>) = input(</mtext><msub><mrow><mtext mathvariant="italic">i</mtext></mrow><mrow><mtext mathvariant="italic">2</mtext></mrow></msub><mtext>, </mtext><mtext mathvariant="italic">n', s')</mtext><mtext> = </mtext><mtext mathvariant="italic">t; t</mtext><msub><mrow><mtext> ∈ V</mtext></mrow><mrow><mtext>T</mtext></mrow></msub><mtext>.</mtext></mrow></math><img file="EP0743599A2_D0005.tif" /></maths>

0073Value <i>v</i>_<i>1</i> is then bound to the transitory <i>t,</i> denoted <b>carrier</b>(<i>v</i>_<i>1</i>) = <i>t.</i> However, in the more general case with <b>output</b>(<i>i</i>_<i>1</i>, <i>n, s)</i> ≠ <b>input</b>(<i>i</i>_<i>2</i>, <i>n', s'),</i> the code generator has to add a <b>move</b> operation <i>m</i> to the DFG, as shown in Figure 6(b).

0074Operation <i>m</i> moves its input value <i>v</i>_<i>1</i> along a path in the ISG, from <b>carrier</b>(<i>v</i>_<i>1</i>) to <b>carrier</b>(<i>v</i>_<i>2</i>), with <i>v</i>_<i>2</i> being its output value. Generally, a <b>move</b> operation is implemented by ISG operations in the set V_I^move ⊂ V_I that contains <b>copy</b> operations to copy values between transitories, <b>read</b> and <b>write</b> operations to access register(file)s, and <b>load</b> and <b>store</b> operations to access memories.

0075The set of ISG operations that are selected by the code generator to implement a particular <b>move</b> operation <i>m</i>, is returned by the function <b>delivery</b>(<i>m</i>). For the data dependency of Figure 6(b), the <b>move</b> operation will be implemented by a series of <b>copy</b> operations, according to following equations (for operations that have one input and one output, <b>input</b>() and <b>output</b>() need only two arguments) :<maths id="math0006" num="(2)"><math display="block"><mrow><mtext>delivery(</mtext><mtext mathvariant="italic">m</mtext><mtext>) = {</mtext><msub><mrow><mtext mathvariant="italic">c</mtext></mrow><mrow><mtext mathvariant="italic">1</mtext></mrow></msub><mtext>, </mtext><msub><mrow><mtext mathvariant="italic">c</mtext></mrow><mrow><mtext mathvariant="italic">2</mtext></mrow></msub><mtext>, ..., </mtext><msub><mrow><mtext mathvariant="italic">c</mtext></mrow><mrow><mtext mathvariant="italic">n</mtext></mrow></msub><msub><mrow><mtext>} ⊂ V</mtext></mrow><mrow><mtext>i</mtext></mrow></msub><msup><mrow><mtext>​</mtext></mrow><mrow><mtext>move</mtext></mrow></msup></mrow></math><img file="EP0743599A2_D0006.tif" /></maths><maths id="math0007" num="(3)"><math display="block"><mrow><mtext>carrier(</mtext><msub><mrow><mtext mathvariant="italic">v</mtext></mrow><mrow><mtext mathvariant="italic">1</mtext></mrow></msub><mtext>) = output(</mtext><msub><mrow><mtext mathvariant="italic">i</mtext></mrow><mrow><mtext mathvariant="italic">1</mtext></mrow></msub><mtext>, </mtext><mtext mathvariant="italic">n, s</mtext><mtext>) = input(</mtext><msub><mrow><mtext mathvariant="italic">c</mtext></mrow><mrow><mtext mathvariant="italic">1</mtext></mrow></msub><mtext>, </mtext><msub><mrow><mtext mathvariant="italic">s'</mtext></mrow><mrow><mtext mathvariant="italic">1</mtext></mrow></msub><mtext>) = </mtext><msub><mrow><mtext mathvariant="italic">t</mtext></mrow><mrow><mtext mathvariant="italic">0</mtext></mrow></msub></mrow></math><img file="EP0743599A2_D0007.tif" /></maths><maths id="math0008" num="(4)"><math display="block"><mrow><mtext>∀k:1 ≤ k &lt; n : output(</mtext><msub><mrow><mtext mathvariant="italic">c</mtext></mrow><mrow><mtext mathvariant="italic">k</mtext></mrow></msub><mtext>, </mtext><msub><mrow><mtext mathvariant="italic">s</mtext></mrow><mrow><mtext mathvariant="italic">k</mtext></mrow></msub><mtext>) = input(</mtext><msub><mrow><mtext mathvariant="italic">c</mtext></mrow><mrow><mtext mathvariant="italic">k+1</mtext></mrow></msub><mtext>, </mtext><msub><mrow><mtext mathvariant="italic">s'</mtext></mrow><mrow><mtext mathvariant="italic">k+1</mtext></mrow></msub><mtext>) = </mtext><msub><mrow><mtext mathvariant="italic">t</mtext></mrow><mrow><mtext mathvariant="italic">k</mtext></mrow></msub></mrow></math><img file="EP0743599A2_D0008.tif" /></maths><maths id="math0009" num="(5)"><math display="block"><mrow><mtext>carrier(</mtext><msub><mrow><mtext mathvariant="italic">v</mtext></mrow><mrow><mtext mathvariant="italic">2</mtext></mrow></msub><mtext>) = input(</mtext><msub><mrow><mtext mathvariant="italic">i</mtext></mrow><mrow><mtext mathvariant="italic">2</mtext></mrow></msub><mtext>, </mtext><mtext mathvariant="italic">n', s'</mtext><mtext>) = output(</mtext><msub><mrow><mtext mathvariant="italic">c</mtext></mrow><mrow><mtext mathvariant="italic">n</mtext></mrow></msub><mtext>, </mtext><msub><mrow><mtext mathvariant="italic">s</mtext></mrow><mrow><mtext mathvariant="italic">n</mtext></mrow></msub><mtext>) = </mtext><msub><mrow><mtext mathvariant="italic">t</mtext></mrow><mrow><mtext mathvariant="italic">n</mtext></mrow></msub></mrow></math><img file="EP0743599A2_D0009.tif" /></maths><maths id="math0010" num="(6)"><math display="block"><mrow><mtext>{</mtext><msub><mrow><mtext mathvariant="italic">t</mtext></mrow><mrow><mtext mathvariant="italic">0</mtext></mrow></msub><mtext>, </mtext><msub><mrow><mtext mathvariant="italic">t</mtext></mrow><mrow><mtext mathvariant="italic">1</mtext></mrow></msub><msub><mrow><mtext mathvariant="italic">, t</mtext></mrow><mrow><mtext mathvariant="italic">2</mtext></mrow></msub><mtext>, ..., </mtext><msub><mrow><mtext mathvariant="italic">t</mtext></mrow><mrow><mtext mathvariant="italic">n</mtext></mrow></msub><msub><mrow><mtext>} ⊂ V</mtext></mrow><mrow><mtext>T</mtext></mrow></msub></mrow></math><img file="EP0743599A2_D0010.tif" /></maths>

0076In Figure 6(c), an allocated data dependency is shown. Such a data dependency is bound to a path in the ISG that includes a static storage element. It also holds for an allocated data dependency that <b>output</b>(<i>i</i>_<i>1</i>, <i>n, s)</i> ≠ <b>input</b>(<i>i</i>_<i>2</i>, <i>n', s'</i>), but now two move operations <i>m</i>_<i>1</i> and <i>m</i>_<i>2</i> are added to the DFG by the code generator. Operation <i>m</i>_<i>1</i> moves <i>v</i>_<i>1</i> from <b>carrier</b>(<i>v</i>_<i>1</i>) ∈ V_T to <b>carrier</b>(<i>v</i>_<i>2</i>) ∈ V_R ∪V_M and<i>m</i>_<i>2</i> moves <i>v</i>_<i>2</i> to <b>carrier</b>(<i>v</i>_<i>3</i>) ∈ V_T.

0077Because <i>v</i>_<i>2</i> is bound to a static storage element, <b>delivery</b>(<i>m</i>_<i>1</i>) will now contain a <b>write</b> or a <b>store</b> operation and analogously <b>delivery</b>(<i>m</i>_<i>2</i>) will contain a <b>read</b> or a <b>load</b> operation. Equations similar to equations (2) to (6) can be written down for each of these <b>delivery</b>() functions.

<u>Correctness constraints of bundles</u>

0078A <b><i>bundle</i></b> is defined as a set of DFG operations that are bound to the ISG and for which following properties hold. Two operations that have a direct data dependency will belong to the same bundle and two operations having an allocated data dependency must be in different bundles. Because of the direct data dependencies, the timing relations between operations in a bundle are fixed and will be the same in the final schedule. Consequently, operations in a bundle may not have encoding conflicts nor hardware conflicts with each other, for any of their operation stages. The code generator can prevent conflicts by changing a direct data dependency into an allocated data dependency, thereby removing the corresponding time constraint and splitting the bundle.

0079In the remainder of this paragraph, some definitions are introduced to eventually define formal correctness constraints for bundles.

0080Let the resources that an operation <i>r</i> ∈ V_O uses during operation stage <i>s</i> be given by<maths id="math0011" num=""><math display="block"><mrow><mtext>resources(</mtext><mtext mathvariant="italic">r, s</mtext><mtext>) = {</mtext><mtext mathvariant="italic">t</mtext><msub><mrow><mtext> ∈ V</mtext></mrow><mrow><mtext>T</mtext></mrow></msub><mtext> |∃</mtext><mtext mathvariant="italic">n</mtext><mtext> : </mtext><mtext mathvariant="italic">t</mtext><mtext> = output(type (</mtext><mtext mathvariant="italic">r</mtext><mtext>), </mtext><mtext mathvariant="italic">n, s</mtext><mtext>)}.</mtext></mrow></math><img file="EP0743599A2_D0011.tif" /></maths>

0081The enabling condition needed in operation stage <i>s</i> for operation r is given by <b>enabling</b>(<i>r, s</i>). The functions <b>resources</b>(<i>m, s</i>) and <b>enabling</b>(<i>m, s</i>) for a <b>move</b> operation <i>m</i> are also defined and respectively yield the appropriate outputs and enabling conditions of ISG operations <i>c</i> ∈ <b>delivery</b>(<i>m</i>). Below, the symbol <i>o</i> will be used, meaning either a refined operation <i>r</i> or a <b>move</b> operation <i>m</i>.

0082The function <b>resources</b>(<i>o, s</i>) can be seen as an access function to a reservation table for operation o (P.M. Kogge, "The Architecture of Pipelined Computers", <u>Advanced Computer Science Series</u>, McGraw-Hill Book Company, 1981). It returns the resources that must be reserved by the code generator for operation <i>o</i> at operation stage <i>s</i>. Similarly, the code generator must reserve the instruction register for operation <i>o</i>, so that at operation stage <i>s</i> it contains one of the instructions returned by <b>enabling</b>(<i>o, s</i>).

0083Further, the functions <b>time</b>(<i>o</i>, <i>s)</i> and <b>time</b>(<i>B</i>, <i>s</i>) are defined to give the absolute time on which stage <i>s</i> of respectively operation <i>o</i> or bundle <i>B</i> is executed. In analogy to an operation stage, a bundle stage is defined as the time step relative to the execution start of the corresponding bundle. The function <b>stages</b>(<i>o</i>) returns the operation stages where operation <i>o</i> claims either a resource or an enabling condition and the function<maths id="math0012" num=""><math display="block"><mrow><mtext>stages(</mtext><mtext mathvariant="italic">B</mtext><mtext>) = {s|∃</mtext><mtext mathvariant="italic">o</mtext><mtext> ∈ </mtext><mtext mathvariant="italic">B</mtext><msub><mrow><mtext>,∃s</mtext></mrow><mrow><mtext>o</mtext></mrow></msub><mtext> ∈ stages(o):time(</mtext><mtext mathvariant="italic">B</mtext><mtext>, </mtext><mtext mathvariant="italic">s)=</mtext><mtext>time(</mtext><msub><mrow><mtext mathvariant="italic">o, s</mtext></mrow><mrow><mtext mathvariant="italic">o</mtext></mrow></msub><mtext>)}</mtext></mrow></math><img file="EP0743599A2_D0012.tif" /></maths> returns the stages where the bundle <i>B</i> claims either a resource or an enabling condition.

0084Finally, the predicate <b>direct</b>(<i>o</i>_<i>i</i>, <i>o</i>_<i>j</i>) is defined to indicate whether <i>o</i>_<i>i</i><i>, o</i>_<i>j</i> ∈ V_O have a direct data dependency and <b>allocated</b>(<i>o</i>_<i>i</i>, <i>o</i>_<i>j</i>) to indicate an allocated data dependency.

0085At this point, the correctness constraints for bundles can be formalised :<maths id="math0013" num=""><math display="block"><mrow><mtext>constraint (7) :   </mtext><msub><mrow><mtext mathvariant="italic">∀o</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><msub><mrow><mtext mathvariant="italic">, o</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub><msub><mrow><mtext> ∈ V</mtext></mrow><mrow><mtext>o</mtext></mrow></msub><msub><mrow><mtext mathvariant="italic">, o</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><mtext> ∈ </mtext><msub><mrow><mtext mathvariant="italic">B</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><msub><mrow><mtext mathvariant="italic">, o</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub><mtext> ∈ </mtext><msub><mrow><mtext mathvariant="italic">B</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub><mtext> : direct(</mtext><msub><mrow><mtext mathvariant="italic">o</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><mtext>, </mtext><msub><mrow><mtext mathvariant="italic">o</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub><mtext>) ⇒ </mtext><msub><mrow><mtext mathvariant="italic">B</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><mtext> = </mtext><msub><mrow><mtext mathvariant="italic">B</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub></mrow></math><img file="EP0743599A2_D0013.tif" /></maths>

0086Constraint (7) expresses that two operations having a direct data dependency must belong to the same bundle. Two operations having an allocated data dependency must be in different bundles :<maths id="math0014" num=""><math display="block"><mrow><mtext>constraint (8) :   ∀</mtext><msub><mrow><mtext mathvariant="italic">o</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><mtext>, </mtext><msub><mrow><mtext mathvariant="italic">o</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub><msub><mrow><mtext> ∈ V</mtext></mrow><mrow><mtext>o</mtext></mrow></msub><msub><mrow><mtext mathvariant="italic">, o</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><mtext> ∈ </mtext><msub><mrow><mtext mathvariant="italic">B</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><msub><mrow><mtext mathvariant="italic">, o</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub><mtext> ∈ </mtext><msub><mrow><mtext mathvariant="italic">B</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub><mtext> : allocated(</mtext><msub><mrow><mtext mathvariant="italic">o</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><mtext>, </mtext><msub><mrow><mtext mathvariant="italic">o</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub><mtext>) </mtext><msub><mrow><mtext mathvariant="italic">⇒ B</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><mtext> ≠ </mtext><msub><mrow><mtext mathvariant="italic">B</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub></mrow></math><img file="EP0743599A2_D0014.tif" /></maths>

0087Because the timing relations between operations in a bundle are fixed and will be the same in the final schedule, operations in a bundle may not have hardware conflicts nor encoding conflicts with each other, for any of their operation stages. This is formalised by the following two constraints :<maths id="math0015" num=""><math display="block"><mrow><mtext>constraint (9) :    ∀</mtext><msub><mrow><mtext mathvariant="italic">o</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><mtext>, </mtext><msub><mrow><mtext mathvariant="italic">o</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub><mtext> ∈ </mtext><mtext mathvariant="italic">B</mtext><mtext>, ∀s ∈ stages(</mtext><msub><mrow><mtext mathvariant="italic">o</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><mtext>), ∀</mtext><mtext mathvariant="italic">s</mtext><mtext>' ∈ stages(</mtext><msub><mrow><mtext mathvariant="italic">o</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub><mtext>) :</mtext><mspace linebreak="newline" /><mtext>time(</mtext><msub><mrow><mtext mathvariant="italic">o</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><mtext mathvariant="italic">, s</mtext><mtext>) = time(</mtext><msub><mrow><mtext mathvariant="italic">o</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub><mtext mathvariant="italic">, s'</mtext><mtext>) ∧ </mtext><msub><mrow><mtext mathvariant="italic">o</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><mtext> ≠ </mtext><msub><mrow><mtext mathvariant="italic">o</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub><mspace linebreak="newline" /><mtext>⇒ resources(</mtext><msub><mrow><mtext mathvariant="italic">o</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><mtext mathvariant="italic">, s</mtext><mtext>) ∩ resources(</mtext><msub><mrow><mtext mathvariant="italic">o</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub><mtext mathvariant="italic">, s'</mtext><mtext>) = φ</mtext></mrow></math><img file="EP0743599A2_D0015.tif" /></maths><maths id="math0016" num=""><img file="EP0743599A2_D0016.tif" /></maths>

0088The last constraint also defines the enabling condition of a bundle at stage <i>s;</i> its resources at stage <i>s</i> are given by<maths id="math0017" num=""><img file="EP0743599A2_D0017.tif" /></maths><maths id="math0018" num=""><img file="EP0743599A2_D0018.tif" /></maths>

<u>Conflict constraints between bundles</u>

0089As all timing relations in a bundle are fixed, the scheduler can use a conflict model between bundles. Therefore conflict constraints are formulated that must hold for a set β of bundles to be conflict free (with c being a control step in the resulting schedule) :<maths id="math0019" num=""><math display="block"><mrow><mtext>constraint (11) :    ∀</mtext><msub><mrow><mtext mathvariant="italic">B</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><mtext>, </mtext><msub><mrow><mtext mathvariant="italic">B</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub><mtext> ∈ β, ∀</mtext><mtext mathvariant="italic">s</mtext><mtext> ∈ stages(</mtext><msub><mrow><mtext mathvariant="italic">B</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><mtext>), ∀</mtext><mtext mathvariant="italic">s</mtext><mtext>' ∈ stages(</mtext><msub><mrow><mtext mathvariant="italic">B</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub><mtext>) :</mtext><mspace linebreak="newline" /><mtext>time(</mtext><msub><mrow><mtext mathvariant="italic">B</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><mtext mathvariant="italic">, s</mtext><mtext>) = time(</mtext><msub><mrow><mtext mathvariant="italic">B</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub><mtext mathvariant="italic">, s'</mtext><mtext>) ∧ </mtext><msub><mrow><mtext mathvariant="italic">B</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><mtext> ≠ </mtext><msub><mrow><mtext mathvariant="italic">B</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub><mspace linebreak="newline" /><mtext> ⇒ resources(</mtext><msub><mrow><mtext mathvariant="italic">B</mtext></mrow><mrow><mtext mathvariant="italic">i</mtext></mrow></msub><mtext mathvariant="italic">, s</mtext><mtext>) ∩ resources(</mtext><msub><mrow><mtext mathvariant="italic">B</mtext></mrow><mrow><mtext mathvariant="italic">j</mtext></mrow></msub><mtext mathvariant="italic">, s'</mtext><mtext>) = φ</mtext></mrow></math><img file="EP0743599A2_D0019.tif" /></maths><maths id="math0020" num=""><img file="EP0743599A2_D0020.tif" /></maths>

<u>Code selection and delayed binding</u>

0090As said above, the code generator binds G_DFG onto G_ISG in subsequent phases. In a first phase, it is decided on which data dependencies will become direct data dependencies, or equivalently, the DFG operations are partitioned into groups, each becoming a bundle eventually.

0091This phase matches graph patterns in the DFG onto graph patterns in the ISG. The DFG operations are refined according to relation (1) and direct data dependencies are bound, as shown in Figure 6(a) and (b), and according to constraints (2) to (6). The code selection tool may add some move operations to the DFG for this. The allocated data dependencies are not yet bound, but it is verified that each bundle input and output can access static storage. It is made certain that the correctness constraints for bundles, constraints (7) to (10), are not violated.

0092However, several binding alternatives may still be possible. In this phase only the partitioning of the DFG operations into bundles is done; the exact binding decision is delayed to a subsequent task. The design, both the DFG and the ISG, is also taken to a higher level of abstraction. For each subgraph in the DFG that is formed by the partitioning above, a new abstract operation <i>g</i> ∈ <i>L</i> is created, and the subgraph is replaced by an instance of operation <i>g.</i> For each valid binding of this subgraph, a new operation <i>b</i> ∈ V_I<i>⊂ L</i> is created. Operation <i>b</i> is inserted in the ISG and is a subtype of operation <i>g</i> in the type hierarchy of <i>L.</i> The enabling condition(s), the resources and the timing of operation <i>b</i> can all be derived from the original ISG and are annotated with <i>b.</i>

0093In this way the same relations are obtained as depicted in Figure 5, but with a DFG and an ISG of much lower complexity. Specific binding possibilities, to be decided on in a subsequent phase, are directly accessible in the library.

<u>Register allocation</u>

0094In a second phase, the (allocated) data dependencies between bundles are bound. This means that for each operation <i>g</i> an implementation <i>b</i> is chosen and move operations are added at their inputs and outputs to access static storage, while satisfying constraints (7) to (10). In addition to the simple paths considered in Figure 6(c), also paths visiting more than one static storage can be needed, for example to spill a register to memory and to reload it. In the latter case, new bundles are inserted that only consist of single <b>move</b> operations.

0095Two important characteristics of the ISG model, which pattern-based models are lacking, are : <ul id="ul0018" list-style="dash" compact="compact"><li>Its graph structure allows the binding problem of values to be formulated as a <b><i>path-search</i></b> problem.</li><li>It supports an <i><b>incremental</b></i> construction of the eventual instructions, by combining elementary actions (either operations or moves) into bundles. By associating <b>resources</b> and <b>enabling</b> attributes with every elementary action, and by defining how these attributes can be combined, an accurate conflict behaviour is available for every partial bundle.</li></ul>

0096These two characteristics are essential for the register allocation tool, to evaluate the impact of the different routing alternatives for a single data dependence on both the global register and timing cost.

<u>Scheduling</u>

0097After register allocation, all operations and values are bound to the ISG, but they must still be bound to time. During this scheduling phase, for each operation also an instruction is chosen from its enabling condition. The objective is to minimise cycle count, thus as many operations as possible should be scheduled in parallel, while satisfying the conflict constraints (11) and (12).

<u>3. ADDITIONAL MODELLING ISSUES.</u>

<u>Control flow operations</u>

0098The basic idea behind modelling the decision making capabilities of a processor in the ISG is to introduce abstract <b><i>control flow operations</i></b><i>.</i> Control flow operations in the ISG are much like data-path operations. They just model the control unit of the processor instead of the data path. A jump operation, for example, assigns a new value to the program counter (PC).

0099Other operations, such as a call to a subroutine or a hardware do loop have a more complex behaviour, the details of which are not put in the ISG as they are unneeded for code generation. Instead an abstract control flow operation is inserted in the ISG and its behavioural model is stored elsewhere and made available to the simulator.

0100Data-path operations in a processor usually do not only generate a result, but also set flags depending on properties of the result. These flags are stored in a status register and can be used by the control flow operations to implement decision making. The generation and the consumption of these flags is modelled in the ISG, as it leads to operation dependencies which are important for code generation.

0101For the purpose of this description, it can be assumed that the application program is represented by a control data flow graph (CDFG), without introducing branch labels or other references to the PC. A small "C" program is shown in Figure 7(a) together with the resulting <b>if-then-else</b> construct in the CDFG. The condition is obtained by subtracting value <b>b</b> from value <b>a</b> and the resulting flags are input of the less-than (<b>LT</b>) operation that yields a boolean value (a bit) needed by the <b>if_expr</b> operation. This <b>if_expr</b> operation selects between the <b>then</b> (if the boolean value is true) and the <b>else</b> (if the boolean value is false) paths in the CDFG, as indicated by the dashed arrows in Figure 7(a). This CDFG can be mapped on the small ISG shown in Figure 7(b) : values <b>a</b> and <b>b</b> are respectively put in registers <b>AX</b> and <b>AY</b>, and the CDFG operations are mapped on the ISG operations with a matching label (i.e. labels consisting of the same symbol). Thus, the ISG must also contain an <b>LT</b> operation. The <b>if_expr</b> operation is refined to a conditional jump operation (<b>CJMP</b>) and mapped to the corresponding operation in the ISG. Together with a non-conditional jump that is added in a later compilation phase, the CJMP operation implements the selection of either the <b>then</b> or the <b>else</b> path in the <b>if-then-else</b> structure.

<u>Conditionally executable instructions</u>

0102A conditionally executable instruction enables some ISG operations if a certain condition is true and is otherwise equal to a NOP instruction that does not enable any operation.

0103A conditional construct like in Figure 7(a) can not be executed by a conditional instruction, because also something must be done when the condition is false. Figure 8(a) contains a similar C example and the corresponding <b>if-then</b> CDFG construct that can be implemented by a conditionally executable instruction. Not only the increment operation is conditional, but also the read and write operations of the operands and result(s) are conditional, and this must be modelled in the ISG. So what is needed is a way to express that an ISG operation like the <b>LT</b> operation enables (or disables) <b><i>a group</i></b> of other ISG operations. For this purpose a macro-node concept is introduced in the ISG.

0104A macro-node is a group of ISG operations and is enabled by the <b>enable</b> operation that it contains, when that <b>enable</b> operation receives a <b>true</b> as input. Other ISG operations contained in a macro-node are active if <b><i>both</i></b> their macro-node is enabled <b>and</b> their enabling condition is satisfied.

0105Figure 8(b) contains a small ISG with a macro-node that is shown as a dashed rectangle. All operations drawn in the rectangle are in the macro-node.

0106The code generator recognises that the pattern of Figure 8(a) can be mapped onto an either the ISG shown in Figure 7(b) or the ISG shown in Figure 8(b). In the latter case, the <b>if_expr</b> operation will be refined to an <b>enable</b> operation, while in the former case it would be refined to a <b>CJMP</b> operation.

<u>Residual control</u>

0107When the execution of an operation does not solely depend on the instructions in the <b><i>instruction register</i></b> but also on some bits in a <b><i>mode register</i></b><i>,</i> that operation is said to be residually controlled. A common example in DSP processors is a <b><i>saturation</i></b> bit, indicating whether an adder must perform saturating or normal additions, which have a different behaviour when an overflow would occur.

0108A residually controlled operation can be modelled by splitting it in several conditionally executable operations, as shown the ISG of Figure 9(a). There two operations are inserted in the ISG, the <b>add</b> has non-saturating behaviour and the <b>add_sat</b> saturates. Each of them is in a macro-node with either an <b>enable</b> or a <b>disable</b> node connected to the register containing the saturate-bit. A <b>disable</b> node enables its macro-node when it receives a <b>false</b> as input.

0109Another way of modelling residually controlled operations is shown in the ISG of Figure 9(b). There an <b>ADD</b> operation <b><i>with an additional input</i></b> is inserted in the ISG. Its behaviour is such that it performs normal additions when the third input is <b>0</b> and performs saturated additions when the third input is <b>1</b>. The <b>add</b> and <b>add_sat</b> operations are expanded by the front-end into <b>ADD</b> operations with the third input connected to the appropriate constant, <b>0</b> or <b>1</b>. This way of modelling allows to elegantly handle the setting and clearing of the saturation bit, just like any other constant that must be present at an operation input and is therefore used in the preferred embodiment.

<u>Data types</u>

0110A storage element physically contains a bit string of a certain length, but on a typical DSP processor not all storage elements have the same bit width.

0111For example, most storage elements of the ADSP-2111 from Analog Devices have a word length of 16 bit, but the address registers are only 14 bit long. Sometimes the behaviour of a processor operation presupposes a data type that is more specific than a bit string, such as e.g. an unsigned integer or a signed fractional number. In the ADSP-2111 from Analog Devices for example, memory addresses, contained in address registers, are supposed to be unsigned integers, while address modifiers, contained in index registers, are supposed to contain signed integers. Each storage element in the ISG is thus annotated with its specific data type, as for example the <b>num</b> data type in Figure 3.

0112To spill a 14 bit register to a 16 bit wide memory, a conversion from 14 to 16 bit is performed while putting the register contents on the data bus. This conversion involves a zero or a sign extension, depending on the assumed data type in the register. This can be modelled in the ISG as shown in Figure 10(a), where a path exists from the 14 bit register to the memory and back. In the latter path, from memory to register, a conversion is done to transform the 16 bit value to a 14 bit value. However, the two most significant bits are lost during this conversion, which is potentially unsafe. While mapping data dependencies on the ISG, the code generator must check on the type safety of move operations, because a move operation then also may contain data type conversions. Therefore each value must be annotated with its data type and its alignment on the storage element.

0113Additionally, the code generator must then know how each ISG operation possibly changes this data type or alignment.

0114In the preferred embodiment of the present invention, another approach is used to guarantee that only type safe data moves are generated. This approach simplifies the data type checks for the code generator, at the cost of a larger ISG. The basic principle is that the code generator will never add any move operation to the DFG that is changing a data type (i.e. all operations in V_I^move preserve their input data type). In fact, the connectivity of the ISG is used to make abstraction of any <b><i>reversible</i></b> type conversion. Each storage element is annotated with a specific data type and may only carry values of that data type. If in reality a physical storage element can carry different data types, an additional storage element carrying that specific data type is inserted for each of them. Such an additional storage element is not a resource, but an alias of the physical storage element and defined by an <b><i>alias relationship</i></b><i>.</i> The <b>resources</b>() function above-described will never return aliases, but always the corresponding physical storage elements, which are the ones used to check for hardware conflicts. Figure 10(b) contains the example of Figure 10(a) modelled in this way, where aliases and their physical storage element are put in a dashed box. For example, when a 14 bit unsigned integer must be spilled, it is spilled to a memory alias with the same data type. In case that the application requires the data type of a value to change, the DFG will contain a conversion operation for this. This operation can then be mapped onto a conversion operation with the appropriate behaviour as for example the <b>conv</b> operation in Figure 10(b).

<u>Record data types</u>

0115Certain registers on a processor have an internal structure, they are constructed out of other registers that are also separately addressable. The accumulator register of most fixed-point DSP processors is an example of such a <b><i>record storage element</i></b><i>.</i> In the example processor described earlier the accumulator register MR is the concatenation of the two registers MR0 and MR1.

0116A record storage element must have a <b><i>record data type</i></b><i>.</i> The elements of the record data type completely match the elements of the record storage element. Indeed, the basic types of the record data type are assigned to the composing storage elements of the record storage element. Aliases can as well be defined for record storage elements as for the composing storage elements, as above-described.

0117The internal structure of a record storage element is captured in the ISG by a structural relationship between the storage element and its composing storage elements. This defines the storage element to be an alias of the concatenation of its composing storage elements and models the overlap of the storage elements. The advantage of defining a record storage element in this way is that it can be accessed as a whole, while it also allows to access the composing storage elements separately. For an operation that occupies a record storage element, the <b>resources</b>() function above-described will thus return the physical storage elements that compose the record storage element.

<u>Functional units</u>

0118Functional units in a conventional net-list model are defined as units having ports which are connected to nets. Operations are defined on these functional units, with their arguments bound to the ports. In the ISG, arguments of operations are directly bound to transitories. Functional units then are optional, they are just a set of operations that are assigned to some data path operator. The specification of functional units is particularly useful when a net-list must be derived from the ISG. In Figure 3, two functional units can be found : alu and sh.

<u>Specification of the ISG</u>

0119In principle, a designer could directly provide the full ISG description to be used by the code generator and instruction simulator programs. Due to the amount of detail in a typical ISG, this would, however, be cumbersome. Instead, a more compact and user-friendly design entry level is provided by specifying a processor with the nML description formalism described in Fauth, Van Praet and Freericks, "Describing instruction set processors using nML", <u>Proc. Europeen Design and Test Conference</u>, Paris, France 1995, and using the so-specified processor as a front-end to the ISG model of the present invention. Other possible front-end descriptions to the ISG model of a processor include a VHDL-description, a C-description or the netlist of said processor. In the sequel, for the purpose of teaching the present invention, the example of nML description is detailed.

0120Although nML contains all the information needed for code generation, it is not a processor model. It does not explicitly show the connectivity of the data-path, nor does it allow efficient look up of all operations with a certain behavior. The nML description formalism is designed to facilitate the task of describing a processor. Its grammar structure aids a human to have an overview of the performed actions in each instruction part, but cannot be efficiently used by code generation phases. Hence, the need exists for the instruction set graph with a structure fitting the graph of the application to be programmed and with the type of hierarchy which is useful for a computer program.

0121The nML front-end is partly based on prior art (see for example, the description concepts of nML set forth below) enhanced with new developments (see for example, the description of adding a structural skeleton to nML, set forth below) to contain all information needed to generate the complete ISG.

<u>Basic Concepts of nML</u>

0122An nML description is written at the level of a programmer's manual. Therefore, most implementation details of the actual machine are hidden, but it contains all information needed for code generation. An enumeration of both the memory locations and-the instruction set of the processor are the basic ingredients of an nML description.

0123Complex architectures may allow hundreds of legal combinations of operations and addressing modes to compose the instruction set. The size of a description can however be reduced by introducing hierarchy and by sharing similarities among a variety of instructions. In an nML description, a grammar based approach is used for that purpose. The production rules in the grammar introduce the structure of the instruction set into the processor description. <ul id="ul0019" list-style="dash" compact="compact"><li>OR-rules are production rules which indicate alternative partial instructions, a different interpretation of fields in the instruction word.</li><li>AND-rules indicate the composition of orthogonal partial instructions into a bigger part, a concatenation of independently controllable fields. Also the leafs in the hierarchy are AND-rules.</li></ul>

0124Each of the strings which can be derived from the grammar symbolizes one instruction of the processor. By itself, such a string contains no useful information. All semantic aspects are held in the (predefined) attributes of the production rules. The <b>action</b> attribute contains the behavior of the instruction part, described in terms of the composing rules or with register transfers. The <b>image</b> attribute holds the values to set the instruction word fields and the <b>syntax</b> attribute describes the assembly language syntax.

0125In nML, addressing modes are defined as <b>mode</b>-rules having an extra <b>value</b> attribute. This value is an expression that results in a memory location. When a <b>mode</b>-rule is referenced in the <b>action</b> attribute- of another rule, it is replaced by its value. A <b>mode</b>-rule can be either an AND-rule or an OR-rule.

0126The hierarchy introduced by the attributed grammar makes an nML description very concise, easy to write and easily maintainable. The structure in the nML description of the example processor of the present invention is shown in Figure 11.

0127An nML description is typically constructed by analyzing the instruction set of the target machine proceeding top-down. For the present example, the three formats are easily reflected in the nML description by capturing the top-level classification in an OR-rule.    <b>opn instruction = computemove | moveaps | ctrl</b>

0128Either a computation with a data move in parallel, a sole data move with absolute addressing or a control-related instruction can be executed. By further zooming into the first category of instructions, two orthogonal parts are found (i.e., two parts of the instruction that can be controlled independently). This is described in an AND-rule:    <b>opn computemove(c:compute,m:move)</b>

0129The parts of the instruction that are composed with this rule are listed in the parameter list. The declaration of a paramater consists of an instantiation name and a reference to some other rule or to a data type (in case of an immediate operand). The description of each orthogonal part is encapsulated in a rule of its own. It often occurs that such a part is even referred to by more than one rule. In our example, the operand class {AX, AR, MRO, MR1} is subsumed in an addressing mode rule:    <b>mode lopd = AX | AR | MRO | MR1</b>

0130This rule is represented by the highlighted node in Figure 11. There are three references to this rule. One reference for <i>opd1</i> of <i>alu,</i> one for <i>opd</i> of <i>shift</i> and one for <i>opd1</i> of <i>alu-shift.</i>

0131For nML, the storages represent the state of the machine and an instruction can be seen as a state transition function. This information is stored in the <b>action</b> attribute. Its value consists of a sequence of statements. In nML, maximum possible parallelism is implicit. A statement must either be an assignment or a conditional as shown in the following two rules. (There is also an if-then-else clause).<img file="EP0743599A2_D0021.tif" />

0132The predefined operators to form expressions include the common "C" operators plus some DSP-related extensions (e.g., exponentiation, bit rotation, bit string selection and concatenation). Other operators are easily added.

0133The definition of an attribute can include references to attributes defined by the parameters of the rule.    <b>opn computemove(c:compute,m:move)</b>    <b>action={c.action; m.action;}</b>

0134The above defines the <b>action</b> of computemove as the sequence of the <b>actions</b> of the instances of <b>compute</b> and <b>move</b>.

0135The binary coding and the assembly language mnemonic are captured in the <b>image</b> resp. the <b>syntax</b> attribute. The value of the <b>image</b> attribute is a bit string, and the value of the <b>syntax</b> attribute is a string.    <b>opn computemove(c:compute,m:move)</b>    <b>image="O"::c.image::m.image</b>    <b>syntax=format(</b>"%<b>s</b> ∥ %<b>s</b>",<b>c. syntax,m.syntax)</b>

0136The <b>image</b> attribute attached to this rule expresses that the binary code for this instruction part consists of a fixed single bit prefix "0" concatenated with the <b>image</b> attributes of the two components. The definition of the <b>syntax</b> attribute is similar. (The function <b>format</b> resembles the "C" library function <b>printf</b>).

0137In addition to the aforementioned <b>opn</b> rules, there are rules to support the description of addressing modes. These <b>mode</b> rules behave similar to <b>opn</b> rules but have an effective address expression. The parallel data moves of our example processor use indirect addressing to compute the effective address.    <b>mode indinc (j:card(2),k:card(2)) = m [r[j]]</b>    <b>action={r[j]=r[j]+[k];}</b>    <b>image="0"::j::k</b>    <b>syntax=format("(R%d++I%d)"j,k)</b>

0138This rule specifies the effective address as well as some code that is used to update the address register. It is used in contexts such as:    <b>mode adrmode = indinc</b> | <b>inddec</b>    <b>opn load (r:regm,a:adrmode)</b>       <b>action = { r=a; a.action; }</b>       <b>image = "00"::r.image::a.image</b>

0139A storage element is declared by giving a name, the size and the element type. For example:    <b>mem m [1024</b>,<b>int(16)]</b>    <b>reg r [4, fix (1,31)]</b>

0140This defines a memory <b>m</b> of 1K with elements of 16 bit integer numbers and a four element register file <b>r</b> of 32 bit fixed-point numbers.

<u>Adding a structural skeleton to nML</u>

0141The foregoing discussion of modelling hardware conflicts via transitories explained how transitories model all possible hardware conflicts in the ISG. These transitories have also been added to the nML formalism, to be able to to use it as a front-end to the ISG model. A transitory is declared like a register or a memory, but with the key-word <b>trn</b>. An nML description starts with specifying a structural skeleton of the processor at the level desired in the ISG, with exception of most read/write ports of static storage elements (see discussion of modelling hardware conflicts via transitories). These are automatically created in the translation from nML to ISG.

0142Instead of complete register transfers, the <b>action</b> attributes now contain operations connected to the storage elements to express the behavior of a partial instruction. In this way, it is possible to specify, for example, different operations writing to the same transitory.

0143The operations in an nML description can be annotated with the functional unit on which they are executing, and can be attributed with timing information. By means of extra attributes to either the operations or the storage elements, it is in fact possible to express all information needed in the ISG.

0144For the description of memory and register read/write operations with different addressing mechanisms, the <b>mode</b> rules are used. However, the semantics of these <b>mode</b> rules have been changed for a better modelling of hardware conflicts. When a <b>mode</b>-rule is referenced in the <b>action</b> attribute of another rule, a distinction is made between two cases. The value can be evaluated as an l-value (a left-value, i.e., the definition of a location to be written) or as an r-value (a right-value, i.e., the definition of a location to be read). An r-value translates into a <b>read</b> operation between the involved static storage element and a transitory modelling its read port; an l-value into a <b>write</b> operation between the static storage element and its write port. Each value can be annotated with the read port and the write port to be used in the respective evaluations.

0145The refined semantics of the <b>mode</b>-rules make that each addressing mode needs only to be described once, while providing the precise modelling of possible hardware conflicts for both the <b>read</b> and <b>write</b> operations.

<u>Use of the Model by the Code Generation and Instruction Set Simulation Programs</u>

0146All the concepts explained are implemented in a retargetable compiler which is detailed in this section. For purposes of teaching the compiler CHESS is chosen as an example of a retargetable compiler. A retargetable compiler needs two inputs: <ul id="ul0020" list-style="none" compact="compact"><li>1. A specification of the target processor.</li><li>2. An application program, for example written in C.</li></ul>

0147On the one hand, the processor specification consists of a description of the data types and operations that are supported in the instruction set of the processor. The processor specific data types and operations are specified in the C language.

0148On the other hand, the processor specification contains a description of the processor architecture and instruction set. This is specified preferably in the nML language.

0149It is the task of the front-end of the retargetable compiler to translate the C and nML descriptions into internal formats used by the retargetable code generator. The processor primitives of the library <i>L</i> are stored in the LIB format (.lib files), the architecture and instruction set description is stored as an instruction set graph or ISG (.isg files), and the non-primitive functions of the processor model and of the application program are stored in a control data flow graph or CDFG format (.cdfg files).

0150It is then the task of the back-end of the retargetable compiler, the retargetable code generator, to perform the code generation phases using these internal formats.

0151An overview of the retargetable compiler is given in Figure 12. The translation of processor and program specifications into the internal models takes place in the first four steps, after this the code generation phases are executed. All steps are explained in the following : <ul id="ul0021" list-style="none" compact="compact"><li>1. The processor specific operations are specified in the C language and this specification is translated into the LIB format by means of the <b>noodle</b> tool. For primitive operations (i.e. operations supported by the instruction set of the processor), only an entry in the LIB is generated; for non primitive operations, also a CDFG view is generated.</li><li>2. The processor instruction set and RT-level architecture are specified in the nML language, and are translated into an ISG by means of the <b>animal</b> tool. Here it is checked that only primitive operations are used in the nML actions. In the ISG, operations are attributed with connectivity and instruction encoding information.</li><li>3. The application program is specified in the C language, and the main function is translated into a main CDFG. If other functions are defined, then these are translated into a separate CDFG and a program specific library is generated for them. For this step, the <b>noodle</b> tool will again be used. Note that the specification file containing the processor specific operations (processor.h) is included in the application program file by means of an #include directive.</li><li>4. As a last step in the front end all non-primitive operations are expanded down to the level of primitives by means of an expansion tool <b>cdfgexp,</b> and the resulting CDFG is then used as the input for the code generator.</li><li>5. This is the first phase of the code generator. Some standard flow graph transformations are done by the <b>floop</b> tool to optimise the CDFG for later mapping on the ISG. These transformations include constant folding, strength reduction, common subexpression elemination, loop invariant code motion and reduction of induction variables.</li><li>6. The <b>cosel</b> tool implements the code selection phase as explained above. The several binding possibilities which are then still possible, are annotated in the LIB and ISG formats. This makes the generation of new .lib and .isg files necessary.</li><li>7. The register allocation phase is performed by the <b>amnesia</b> tool, as also explained above.</li><li>8. The <b>mist</b> tool schedules the CDFG and thus binds operations to time steps, choosing an instruction for each operation from its enabling condition, see also above.</li><li>9. The CDFG is then translated to binary code by the assembly tool. This also includes the assignment of values to fields within a register file, and the generation of up until then unspecified addresses.</li></ul>

0152Steps 1 and 2 need to be executed once for every processor design iteration, the other steps need to be executed once for every change to the application program.

<u>A simulator generator based on the ISG</u>

0153The ISG model is also used as processor model in a retargetable simulator generator. In the sequel, for the purposes of teaching, the retargetable simulator generator CHECKERS is detailed. In fact the instruction level simulator can be an executable C++ program that is automatically generated by analysing the ISG. The flow of this process is shown in Figure 13. The first two steps are completely the same as for the retargetable compiler. In a third step the ISG is analysed by the tool <b>checkers</b> to generate the C++ program. This tool topologically sorts the operations in the ISG according to their connections and optimises the enabling conditions so they can be evaluated fast. The C++ program basically is a list of calls to the functions containing the behavioural models of the ISG operations, with each call being guarded by the corresponding enabling condition. The functions containing the behavioural models are described in the processor.c file. The last step to build the simulator is to compile the C++ program together with the processor.c file with a C++ compiler. This yields the instruction set simulator.

0154In the preferred embodiment, the resulting instruction level simulator interpretes a stream of non-preprocessed instructions to simulate the behaviour of processor. It is also possible to input this instruction stream to the simulator generator in which case the resulting C++ program would contain a behavioural model of the processor for the given instruction stream.

<u>Implementation of the ISG</u>

0155In this Section, the implementation of the preferred embodiment of the ISG is explained. The flowdiagram of the program that performs the translation is shown in Figure 14. The objects that make up the embodiment of the ISG and the relationships between these objects are captured in the information structure diagram shown in Figure 15.

<u>Objects of the instruction set graph</u>

0156<ul id="ul0022" list-style="dash" compact="compact"><li>The <b>ISG</b> object represents the instruction set graph.</li><li>The <b>ISGoperation</b> object represents an element of the set V_I; and all the properties of such an element. These properties are for example the type of operation and the enabling condition of the operation.</li><li>The <b>Storage</b> object represents an element of the set V_s, and all the properties of such an element. These properties are for example the capacity of the storage and the data type of the values that the storage can hold.</li></ul>

0157A storage object can be any one of the following three subtypes: <ul id="ul0023" list-style="dash" compact="compact"><li>A <b>Memory</b> object, representing a static storage element, usually with a large capacity and for which the access operations take relatively long.</li><li>A <b>Register</b> object, representing a static storage element, usually with a small capacity and for which the access operations take much less than a machine cycle.</li><li>A <b>Transitory</b> object, representing a transitory storage element.</li></ul>

0158This supertype/subtype relationship is indicated by the thick line in Figure 15. <ul id="ul0024" list-style="dash" compact="compact"><li>The <b>ISGoperator</b> object represents a functional unit.</li></ul>

<u>Relationships between the objects of the instruction set graph</u>

0159<ul id="ul0025" list-style="dash" compact="compact"><li>An <b>ISG</b> contains zero or more <b>Memorys,</b> as indicated by the memories relationship; a <b>Memory</b> belongs to exactly one ISG, as indicated by the <b>isg</b> relationship.</li><li>An <b>ISG</b> contains zero or more <b>Registers</b>, as indicated by the <b>registers</b> relationship; a <b>Register</b> belongs to exactly one ISG, as indicated by the <b>isg</b> relationship.</li><li>An <b>ISG</b> contains zero or more <b>Transitorys</b>, as indicated by the <b>transitories</b> relationship; a <b>Transitory</b> belongs to exactly one <b>ISG</b>, as indicated by the <b>isg</b> relationship.</li><li>An <b>ISG</b> contains zero or more <b>ISGoperations,</b> as indicated by the <b>operations</b> relationship; a <b>ISGoperation</b> belongs to exactly one ISG, as indicated by the <b>isg</b> relationship.</li><li>An <b>ISG</b> contains zero or more <b>ISGoperators,</b> as indicated by the <b>operators</b> relationship; a <b>ISGoperator</b> belongs to exactly one ISG, as indicated by the <b>isg</b> relationship.</li><li>A <b>Storage</b> has zero or more <b>ISGoperations</b> that read from it, as indicated by the <b>read operations</b> relationship; a <b>ISGoperation</b> has zero or more <b>Storages</b> it reads from, as indicated by the <b>inputs</b> relationship.</li><li>A <b>Storage</b> has zero or more <b>ISGoperations</b> that write to it, as indicated by the <b>write operations</b> relationship; a <b>ISGoperation</b> has zero or more <b>Storages</b> it writes to, as indicated by the <b>outputs</b> relationship.</li><li>A <b>Storage</b> can be the child alias of zero or one other <b>Storage</b>, as indicated by the <b>alias</b> of relationship; a <b>Storage</b> can be the parent alias of zero or more other Storages, as indicated by the <b>aliases</b> relationship.</li><li>An <b>ISGoperator</b> can be the functional unit on which zero or more <b>ISGoperations</b> are defined; as indicated by the <b>operations</b> relationship; an <b>ISGoperation</b> can be defined on zero or one <b>ISGoperators,</b> as indicated by the <b>functional unit</b> relationship.</li></ul>