Abstract:
The invention describes a method for expanding (flattening) hierarchical descriptions of electronic circuits into flat descriptions. The method is characterized by two processes: one which eliminates feed-through and implicit signals, and another which pre-plans the layout of the flattened data structure before flattening. The flattening process may then take advantage of a number of resulting efficiencies to operate more quickly than present flatteners.

Description:
TECHNICAL FIELD OF THE INVENTION 
     The present invention relates to the process of expanding, or flattening hierarchical design descriptions, and particularly to flattening such descriptions on electronic computer-aided-design (ECAD) systems. 
     BACKGROUND OF THE INVENTION 
     Modern electronic systems are often designed with the assistance of electronic computer-aided-design tools, hereinafter referred to as ECAD tools. Typically, a user will capture a schematic diagram or other convenient form of circuit description on a display screen of an ECAD system using any of a number of interactive or automatic (e.g., module generators, silicon compilers, logic synthesizers) techniques widely known in the present art. As a part of the design process, a designer will typically capture and compile a design and then simulate it through the use of a logic simulator. 
     Complex logic circuits are customarily described hierarchically, but are simulated flat (or fully expanded). This means that if a module A in a user&#39;s design contains three instances of a submodule B, and submodule B contains two instances of another submodule C, the user will declare only two copies of submodule C in the process of capturing his design, but because of the implied replication in the user&#39;s design, the simulator will simulate six instances of submodule C for each instance of module A, since there are two instances of submodule C in each of the three instances of submodule B comprising module A. When such a circuit description is modified and re-simulated, a program must read the hierarchical description and produce a flat, or fully expanded, description of the hierarchical design before the simulation may be accomplished. A program that accomplishes this function is called a &#34;linker&#34; or &#34;flattener&#34;. Hereinafter, the terms &#34;link&#34; and &#34;flatten&#34; will be used interchangeably. All modern ECAD systems include such a program, since a flat circuit description is too cumbersome for users to create directly, and a hierarchical description cannot easily be simulated directly, because the many different instances of the submodules of a hierarchy may be in different states during simulation and must be dealt with individually by the simulator. 
     Inputs to a linker generally consist of a set of circuit descriptions of different hierarchical levels or &#34;modules&#34; in a circuit. Each module description contains a list of submodules, internal wires (also called &#34;signals&#34; or &#34;nets&#34;) , and I/O (input/output) pins. Each I/O pin of the module&#39;s submodules is connected to one of the module&#39;s internal wires. Some of those wires are in turn connected to I/O pins of the module itself. The details of these interconnections are also a part of the module description. In addition, the module description contains the name of the module, the name of each submodule, internal wire, and I/O pin the module comprises. Any module may itself be a submodule of another module; further illustrating the impact of hierarchy on a design. 
     These inputs to the linker may be either memory-resident data structures, or data structures contained in files on an on-line mass-storage device. Since it is a relatively trivial process to move data structures between files and memory, it will be assumed hereinafter without loss of generality that all linker inputs are memory-resident. 
     The output from a linker is a flattened, or expanded, description of the input circuit descriptions. It contains an explicit representation of every copy of every bottom-level submodule in the circuit design. The term &#34;bottom-level submodule&#34; refers to submodules at the bottom level of a circuit hierarchy for which no further expansion is possible, i.e., submodules which comprise no further submodules. Hereinafter, such bottom-level submodules will be referred to interchangeably as &#34;primitives&#34;. Each primitive has I/O connections (pins) which are explicitly represented, but which may be replicated in multiple instances of the primitive. Connections between I/O pins of primitives may be made at a higher level of hierarchy where the details of the lower levels of circuit interconnection are not explicitly visible, but which do exist. 
     Some ECAD systems have special features which complicate the process of linking, or flattening, a design description. Some examples of such features are: 
     a. Global Signals: 
     This feature allows wires to pass from one module to another without passing through explicitly declared I/O pins of either module. This is primarily used for &#34;universal&#34; signals such as power supplies and master clocks. Because these connections are &#34;assumed&#34; and not explicitly declared in a circuit description, a linker must deal with these signals in a less straightforward fashion than would otherwise be possible. 
     b. Primitive modules with variable numbers of I/O pins: 
     This capability is used mainly for RAM (random access memory) primitives so that one primitive may be used to describe RAMs of many different sizes. An instance of such a primitive would have as part of its description a list of parameters which would affect the number and type of I/O pins on that instance of the primitive. Again, a linker would have to handle this special situation. 
     c. Primitives with unconnected inputs: 
     Simple logic gate primitives may have unconnected inputs. For example, a 3-input NAND gate may have one input unconnected. The ECAD system would recognize the condition and compute a 2 input NAND function in its place. The makes it unnecessary to have separate 2-input and 3-input NAND primitives. This situation must be taken into account by a linker. 
     d. Module I/O pins wired together: 
     &#34;Feed-through&#34; pins are sometimes allowed by ECAD systems. In these cases, two pins are declared and shown graphically, but are wired together internally. This is usually done as a graphical convenience to the ECAD user. A linker would have to replace two or more nets connected to pins of this type with a single net, since all are connected together in the lower levels of hierarchy. 
     e. Connections by position and by name: 
     Some ECAD systems allow wires to be attached either to a submodule pin with a specified name or to a submodule pin in a specified position. If one wire is connected to a pin named &#34;X&#34; and another wire is connected to a pin number 3, it is the responsibility of the linker to determine whether those wires are connected to each other by checking whether pin number 3 is named &#34;X&#34; or not. This requires linker actions similar to those for module pins wired together. 
     Typically, schematic capture tools use connection by name, while automatic module generators use connection by position. The ability to support both styles would be of value and, as will become evident, is incorporated in the present invention. 
     Typical linker (or flattener) programs consist of four main processing tasks. These are: 
     a. Loading the hierarchical design description. 
     b. Altering the module designs to reflect information about their submodules (such as implicit power connections, multiple pins with the same signal, etc.) which was not previously available. The effect is to explicitly reference any portions of the submodule which would otherwise be considered implicit. This step is not required if certain design restrictions are placed on the design methodology which eliminate the possibility of feed-through connections or &#34;implied&#34; connections where a connection may be made without a user-drawn &#34;wire&#34;. This task is performed by using a pin-name list or equivalent data structure to merge signals (also called wires or nets) which are not explicitly connected by a wire, but which are assumed to be connected by name or other convention. 
     c. Creating copies (instances) of those (sub)module descriptions which are used more than once, i.e., if a module is applied to a circuit design more than once, it is necessary to replicate the module description (or at least those parameters which make an instance of a module unique) so that a subsequent simulation process may treat each instance of the module separately. This is accomplished by scanning the module design and creating a copy each time a module instance is detected; then performing the same operation recursively to the copy. This process creates a flattened representation (or design description) of the input hierarchical design, typically in the form of a tree structure. Typically, the entire module description is not copied for each instance. Instead, each copy will typically contain a reference to the master copy and parameter space for information about explicit connections and internal state. The reference to the original allows information which is common to all instances of a module to be shared, saving time and storage space. 
     d. Connecting the copies together in accordance with the wiring directions found in each module design. That is, information relating to inter-module connections is stored in the copies of the module descriptions, allowing further processing steps to have full knowledge of signal routing within the circuit design. This task is performed by visiting every submodule I/O pin in the flattened design description, and tracing through the hierarchical design description to find every other I/O pin in the flattened design which connects to it. This involves traversing the various levels of hierarchy from module description to module description, until all interconnections in the flattened design have been resolved. When this process is complete, each group of commonly connected pins will have a &#34;net&#34; assignment, and each module I/O pin will have been marked with the number or name of the net to which it is connected. This task is typically the most time-consuming of the four tasks listed here. 
     An approach which combines the tasks of creating and connecting copies (c and d, above) is reported by Mentor Graphics Corp. in Paper 39.3 of the 1988 DAC (25th ACM/IEEE Design Automation Conference) Proceedings. This paper describes a technique whereby the module description copies are wired together (i.e., nets are created and I/O pins assigned to them) as the copies are created. The technique provides a substantial performance improvement over the typical process described above, but does not provide for resolution of feed-through pins. 
     As will become evident hereinafter, the present invention is considerably faster than the Mentor algorithm; only the factor is smaller. 
     The primary disadvantage of present linking algorithms is that they are slow, and some are inflexible. Engineers typically spend most of their design time in an &#34;Edit-Compile-Simulate&#34; iterative process. After simulating a version of a circuit design, an engineer will typically make a modification which he hopes will improve the circuit performance or correct a problem detected in simulation. He then runs the programs which prepare the circuit for simulation (that is, he &#34;compiles&#34; the circuit), re-simulates, studies the simulation output to determine success or failure of the circuit modifications and determines whether further modifications are required. Any decrease in the time required to prepare a circuit for simulation provides a direct time benefit to the engineer which is experienced as many times as the &#34;Edit-Compile-Simulate&#34; process is repeated. 
     DISCLOSURE OF THE INVENTION 
     It is therefore an object of the present invention to provide a method of flattening hierarchical design descriptions which is more time-efficient than previous methods. 
     It is a further object of the present invention to provide a time-efficient method of flattening hierarchical design descriptions which is capable of supporting feed-through signals. 
     It is a further object of the present invention to provide a time-efficient method of flattening hierarchical design descriptions which is capable of supporting implicitly declared signals, such as global clock signals. 
     It is a further object of the present invention to provide a time-efficient method of flattening hierarchical design descriptions which is capable of supporting signals connected to modules by either name or position, even if no cross-reference table is available prior to linking. 
     It is a further object of the present invention to provide a time-efficient method of flattening hierarchical design descriptions which is capable of supporting primitives with unconnected inputs. 
     It is a further object of the present invention to provide a time-efficient method of flattening hierarchical design descriptions which is capable of supporting primitives with variable numbers of pins. 
     According to the present invention, there is provided a method for flattening (linking) hierarchical design descriptions. 
     The method, in total, involves nine steps, described hereinafter, but is most readily understood in terms of how it differs from the methods of the prior art. It differs in at least two important features: 
     According to a first feature of the invention, feed-through information and information about implicit connections is propagated up through the design hierarchy before the flattening process begins. Variable pin connections apply only to primitives and have no effect on higher-level modules, so the information is not propagated up. 
     According to a second feature of the invention, a plan for the layout of the flattened data structure is created before making any module copies (i.e., instantiating modules or submodules). 
     The process of propagating feed-throughs prior to flattening allows signals which are distinct in a particular module design but which are actually equivalent in a submodule to be merged, and for signals that are implicitly present in a module design to be made explicit, such that hierarchical module designs accurately reflect the actual electrical connectivity of the represented circuit. This makes it possible to merge the process of net assignment into the process of module replication, while still supporting the special features of feed-through pins. Since a module may contain a feed-through that passes through a feed-through in a submodule, it is essential that this information be computed for all submodule types used directly or indirectly by a given module type before the feed-through information for that module type is computed. For this to be done, a &#34;level number&#34; specifying the number of (hierarchical) levels between a given module type and the lowest level of the hierarchy is computed for each module type. The feed-through analysis is performed on the module types in order from the lowest level to the highest, and effectively eliminates feed-throughs in the flattened design by combining equivalent nets into a single net. The same order is used for analysis of implicit connections, since a signal implicitly present in a submodule is thereby also implicitly present in the module that contains the submodule. 
     The terms &#34;module type&#34; and &#34;submodule type&#34; are used herein to refer to distinct module designs which may be incorporated into other modules. For example, a two input NAND gate may be one module type and a two input NOR gate may be another module type. Each may be included many times in other module designs. Another module type may be created which is created of these two module types, and which may be further included in other modules. A module type is a description of a circuit structure, whereas a &#34;module&#34;, a &#34;submodule&#34;, or an &#34;instance&#34; of a module type (or just &#34;instance&#34;) is a particular usage of a module type. 
     The process of pre-planning the layout of the flattened data structure before copying module descriptions pre-computes the relative positions of each part of every substructure within the overall flattened data structure and specifies the offset of every substructure within the structure which contains it. These positions and offsets are computed once for each reference to a module design within another module design. While the number of these references and their associated position/offset pairs is greater than the number of distinct types of modules, it is much smaller than the number of module instances in the flattened design data structure. 
     This pre-planning is a distinctly different approach than that of the prior art where every address in a copy of a module is calculated by a complicated algorithm. In the present invention, all of these calculations are avoided, and are replaced (in a manner of speaking) with a simple position/offset addition using pre-calculated positions and offsets. As a result, the time spent in the flattening process is greatly reduced. 
     The pre-planning process divides the I/O pins of a module&#39;s submodules into two classes: those that are connected to higher level modules and those that are not. 
     An example of submodule pins not connected to higher level pins is the case where submodules&#39; pins in a higher level module design are inter-connected, but the net that connects them does not connect to the external pins of the module. A graphic example of this is shown in FIG. 1e where signal 565 inter-connects an output pin of module 510 to an input pin of module 530, but has no further external connections. By way of contrast, signal 560 connects an input of module 540 and an input of module 520 to two external module connection points labeled &#34;S&#34; and &#34;SF&#34;. 
     It should also be noted that the inter-connection of external connection points &#34;S&#34; and &#34;SF&#34; is an example of a feed-through connection, where two external connections are electrically identical at a lower level. 
     The net ID numbers of pins that are not connected to higher level modules are computed in the same way that other addresses are computed, by an offset and relative position technique. Each pin which is connected to a higher-level pin is marked in its data structure to indicate which higher level pin it is connected to. When the module copies are created, they are created from the top down, i.e., starting at the highest levels of hierarchy and moving downward. Thus, the ID number of the higher level pin that a submodule I/O pin connects to has already been computed when the ID number of the submodule I/O pin is to be determined. This ID number can then simply be copied from the higher level pin, since electrically they are one and the same. As a result, the time spent in creating the net list or interconnection list is reduced. 
     In order to determine the relative positions and offsets of pin ID numbers, the number and connectivity of internal nets of modules must be determined. This information can be affected by the presence of feed-throughs in the module&#39;s submodules. This means that this pre-planning technique cannot be used unless feed-throughs are prohibited, or a method for handling them such as is described above is used. 
     According to an aspect of the invention, the entire flattened data structure resides in a block of contiguous memory segments, due to the pre-computed address/offset scheme. This means that storage space in memory can be assigned all at once, rather than in small, ad hoc, time-consuming pieces. The allocation of block (preferably contiguous) memory space is feasible, because a side-effect of the pre-planning process is that the total memory space required for the flattened design is computed (i.e., known) before the actual expansion (flattening process) begins. This feature of allocating (requesting) memory in one large lump eliminates much of the time spent in memory allocation by some flatteners of the prior art. Preferably, memory allocation is in a physically contiguous block. However, it can also be a small number of contiguous blocks of memory, for example having a contiguous physical memory block for each instance array. 
     Such block memory allocation is responsible for a small performance improvement. 
     In the flattened design description, sub-structures representing two instances of the same module type are very similar to one another, but not identical since interconnections and instance names differ. As a result, they cannot be copied as a whole. Since they sit in different parts of memory their internal structure is represented by different memory addresses. In spite of these differences, their overall structures are substantially alike. A fundamental difference between the present invention and the prior art is that the present invention takes advantage of this similarity in ways that the prior art does not, to speed the process of expansion. 
     Other objects, features and advantages of the present invention will become apparent in light of the following description thereof. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIGS. 1a-1g are schematic diagrams representing various levels of hierarchy and their respective schematic symbols for an exemplary hierarchical design to be flattened by the method of the present invention. 
     FIGS. 2a-2d are &#34;effective&#34; schematic representations of a top-down progressive expansion (flattening) of the exemplary design shown in FIGS. 1a-1g. 
     FIG. 3 is a graphical representation of a data structure created in the process of executing the method of the present invention, with respect to the example of FIGS. 1a-1g and 2a-2d. 
     FIG. 4 is a representation of a memory map for the flattened, simulable representation of the design of FIGS. 1a-1g and 2a-2d. 
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
     Before the process of analyzing and flattening a hierarchical design may begin, a computer program must collect descriptions of all of the modules. It reads in the top-level module, scans it for submodules and reads in their descriptions. Then the submodules are scanned in similar fashion for further submodules, whose descriptions are then read in. This process continues in like manner until the bottom level of hierarchy is reached and only primitives (bottom-level submodules) remain. Most linkers/flatteners of the prior art begin in this manner. Once the module descriptions are loaded, the process of the present invention begins. 
     The complete process of the present invention comprises nine main steps: 
     Step 1. 
     Creating (from whole cloth, so to speak) a highest level module to contain all other modules (i.e., the entire whole circuit description). This &#34;top&#34; module has internal signals for each I/O pin and top-level global signal. The &#34;top&#34; module includes all external connections as internal nets and has no I/O pins. This eliminates the need for special code to handle boundary conditions. 
     Step 2. 
     Determining the level of each module type in the hierarchy, that is, determine the number of levels between it and the bottom level of the hierarchy. For example, a primitive is defined as a bottom level (Level 0) module type and therefore has a level of zero. A module type with no submodules other than primitives has level one. A module type containing modules of level 1 but no higher has level 2, etc. The &#34;top&#34; module is at the highest level &#34;n&#34;. 
     Step 3. 
     Placing the module descriptions in a list sorted in order of increasing hierarchical level. 
     Step 4. 
     Standardizing the module pin connection orders, that is, re-ordering the list of connections to each module of the same type so that they occur in exactly the same order by pin function. If some pins have been left unconnected, new internal wires (nets) must be created for those pins. If two wires are connected to the same pin, one by name and one by position, the wires must be merged into a single net. This involves destroying the net description for one of the wires and connecting every I/O or submodule pin that was connected to it to the net description for the other wire. If necessary in a specific design environment, bi-directional pins and variable input primitives may receive special treatment in this step since they each may represent one or more of these conditions. 
     Step 5. 
     Resolving all references to global variables. Each module type has a list of all global variables it uses (implicit connections from higher level modules) and all that it defines (provides for implicit connections to lower level modules). For each module description on the sorted list, all global signals used by any submodule of that module are found and any which are not already used or defined by that module are added to the list of global signals used by the module. This step has the effect of explicitly declaring all implicit connections to a module. 
     Step 6. 
     Identifying pins and wires which are connected together. This step determines what distinct internal wires a module type has, and what external wires enter the module type through I/O pins and global signals. If two pins are wired together, this step marks them as being connected to the same external wire. If two internal wires are connected through a submodule, one wire is deleted and the pins connected to it are reconnected to the other wire as in step 4. Each submodule I/O pin and global signal used by any submodule is associated with an internal or external wire. At the completion of this step, all feed-throughs will have been effectively &#34;eliminated&#34; and implicit signals will have been converted to explicit signals, resulting in a simplified (&#34;plain-vanilla&#34;) version of the hierarchical design. (The feed-throughs are all still present in the circuit, but they become irrelevant electrically since each one connects some higher-level module&#39;s signal to itself. Feed-throughs are thus accounted for, and are not ignored.) 
     This process of propagating feed-throughs prior to flattening allows signals which are distinct in a particular module design but which are actually equivalent in a submodule to be merged such that hierarchical module designs accurately reflect the actual electrical connectivity of the represented circuit. This makes it possible to merge the process of net assignment into the process of module replication (see step 9, below), while still supporting the special feature of feed-through pins. Since a module may contain a feed-through that passes through a feed-through in a submodule, it is essential that this information be computed for all submodule types used directly or indirectly by a given module type before the feed-through information for that module type is computed. For this to be done, a level number specifying the number of levels between a given module and the lowest level of the hierarchy is computed (in Step 2) for each module type. The feed-through analysis is performed on the module types in order from the lowest level to the highest, and effectively eliminates feed-throughs in the flattened design by combining equivalent nets into a single net. 
     Again, the terms &#34;module type&#34; and &#34;submodule type&#34; are used herein to refer to distinct module designs which may be incorporated into other modules. For example, a two input NAND gate may be one module type and a two input NOR gate may be another module type. Each may be included many times into other module designs. Another module type may be created which is created of these two module types, and which may be further included into other modules. 
     A &#34;module type&#34; is a description of a circuit structure, whereas a &#34;module&#34;, a &#34;submodule&#34;, or an &#34;instance&#34; of a module type (or just &#34;instance&#34;) is a particular usage of a module type. 
     Step 7. 
     Computing (counting and totalizing) the number of internal wires, submodules, and submodule pins directly or indirectly contained in each module type. In step 6, above, the number of these items used in each module type was made available by making all declarations explicit. This step adds them up hierarchically. A module contains the number of items that it directly contains plus the number contained directly or indirectly be each of its submodules. As this step of the method of the present invention proceeds for a module type, it keeps a running total of the item counts, and attaches them to the record for each submodule before it adds in that submodule&#39;s contribution to the counts. Thus each submodule record contains the partial sum of the counts for all previous submodules of the same module. These partial sums will be used as offsets into arrays in order to determine the location of the submodules of the module instance relative to the location of the module instance itself. 
     Step 8. 
     Allocating memory for the output data structure. Step 7, above, computed the number of items of various sorts contained in the module description for each module type. These figures for the top level module can be used to determine the amount of memory required for the flattened design description. Arrays of module instances, pin instances and wire instances are allocated. 
     Step 9. 
     Recursively flattening the circuit. The flattening routine takes four inputs: the module instance description of the module to be flattened, and pointers into the interiors of the three arrays of the flattened design description. A first pointer into the instance array specifies where that instance of the module being flattened is to be placed. A second pointer into the wire array specifies where the sub-array of internal wires for that instance is to be placed. A third pointer into the pin array specifies where the pins of that instance have been placed. 
     The offset to the first submodule which was computed in step 7 is added to the pointer into the instance array to get the pointer to the instance&#39;s submodules. This is stored in the instance record. The pointer into the pin array is also stored there. Then the records for the pins of the module instance&#39;s submodules are filled in. An offset (computed in Step 7) is added to the pin array argument to find their locations. Each pin record is given a pointer to the record for the submodule it belongs to. Each pin that is connected to an internal wire of the module is given a pointer to that wire by adding the wire number computed in step 6 to the pointer into the wire array. Each pin that is connected to an external wire is given a pointer to that wire by copying the pointer to that wire stored in the record for the appropriate I/O pin of that module. In step 6, the pin number of the correct pin was computed and the pin record itself is found by adding the pin number to the pointer into the pin array that was passed to the flattening routine. The record already contains the right wire because it was processed in the previous invocation of the recursive flattening routine. 
     Finally, each submodule of the module instance is given a parent pointer to the instance record, and is then itself flattened. The recursive call to the flattening routine is passed the module description of the submodule instance, the location in the instance array where it is to be placed, and pointers into the pin and wire arrays, which are found by adding the original pointer arguments to offsets computed in step 7. When this recursive processing step bottoms out (completes), the flattened circuit description is complete. (see FIG. 4) 
     As a generalized example, suppose module &#34;A&#34; contains three instances of module &#34;B&#34;, module B contains two instances of module &#34;C&#34; and one instance of module &#34;D&#34;, and module C contains one instance of module &#34;E&#34; and one instance of module &#34;F&#34;. The instances will appear in the instance array as follows: 
     
         ______________________________________0:    A1:            B1      B2     B34:                    C11    C12     D117:                           E111    F1119:                           E121    F12111:                   C21    C22     D2114:                          E211    F21116:                          E221    F22118:                   C31    C32     D3121:                          E311    F31123:                          E321    F321______________________________________ 
    
     The direct submodules of a module are placed in a contiguous array. The indirect submodules (e.g., sub-submodules) are placed after the direct submodules. 
     When the method of the present invention is used, the direct and indirect submodules of a module always have the same relative positions to one another in the instance array for all instances of the module, but may be a variable distance from the location of the module in the instance array. In this example, the distance in the instance array from C11 to E121 is the same as the distance from C21 to E221, since they are submodules of two instances of module B. However, the distance from B1 to C11 is less than the distance from B2 to C21. Thus, the description of module A must contain information about the distances from B1 to C11 and from B2 to C21, but need not contain information about the relative positions of the subcomponents of B1 and B2. Since it is only stored once for all three copies of B, it need be computed only once. Since traditional flattening algorithms compute the location of subcomponents directly without first determining relative positions, they must in effect recompute information for every instance of a module while the method of the present invention computes this same information only once for each module type. 
     With particular reference to Steps 6, 7 and 9, the process of pre-planning the layout of the flattened data structure before copying module descriptions pre-computes the relative positions of each part of every substructure within the overall flattened data structure, and specifies the offset of every substructure within the structure which contains it. These positions and offsets are therefore computed once for each reference to a module design within another module design. While the number of these references and their associated position/offset pairs is greater than the number of distinct types of modules, it is much smaller than the number of module instances in the flattened design data structure. This is distinctly different than the prior art where every address in a copy of a module is calculated by a complicated algorithm. Each such calculation is eliminated and replaced with a simple position/offset addition using pre-calculated positions and offsets. As a result, the time spent in the flattening process is greatly reduced. 
     The pre-planning process divides I/O pins of a module&#39;s submodules into two classes: those that are connected to higher level modules and those that are not. An example of submodule pins not connected to higher level pins is the case where submodules in a higher level module design are interconnected, but the net that connects them does not connect to the external pins of the module. A graphic example of this is shown in FIG. 1e where signal 565 interconnects an output pin of module 510 to an input pin of module 530, but has no further external connections. By way of contrast, signal 560 connects an input of module 540 and an input of module 520 to two external module connection points labeled &#34;S&#34; and &#34;SF&#34;. 
     It should also be noted that the interconnection of external connections points &#34;S&#34; and &#34;SF&#34; is an example of a feed-through connection, where two external connections are electrically identical at a lower level. The net ID numbers of pins that are not connected to higher level modules are computed in the same way that other addresses are computed, by an offset and relative position technique. Each pin which is connected to a higher-level pin is marked in its data structure to indicate which higher level pin it is connected to. When the module copies are created, they are created from the top down, i.e., starting at the highest levels of hierarchy and moving downward. Thus, the ID number of the higher level pin that a submodule I/O pin connects to has already been computed when the ID number of the submodule I/O pin is to be determined. This ID number can then simply be copied from the higher level pin, since electrically they are one and the same. As a result, the time spent in creating the net list or interconnection list is reduced. 
     In order to determine the relative positions and offsets of pin ID numbers, the number and connectivity of internal nets of modules must be determined. This information can be affected by the presence of feed-throughs in the module&#39;s submodules. This means that this pre-planning technique cannot be used unless feed-throughs are banned or a method for handling them like the one described above is also used. 
     EXAMPLE 
     Consider the example design of FIG. 1(a-f), which is a design for a four-bit barrel shifter. The example is a multi-level hierarchy containing feed-through signals. Note that pins on graphical representations of submodules are denoted in this example by small dots. 
     FIG. 1a shows a low hierarchical level schematic representation of a 0/1 bit shifter module 100 comprising four submodules: inverter 150 and multiplexers 120, 130 and 140. As it happens, the design of the multiplexers makes use of feed-through connections, and two types of feed-through are illustrated. Their primary purpose in this case is one of graphical convenience. The &#34;S&#34; input of each multiplexer is replicated at the top of each multiplexer instance. While wires 160, 165, and 170 appear to be separate and unique wires, they are in fact connected in the multiplexer submodules by virtue of a feed-through connection in the module type. 
     The 0/1 bit shifter module 100 has inputs 102, 104, 106, 108, and 110, labeled &#34;A.3&#34;, &#34;A.2&#34;, &#34;A.1&#34;, &#34;A.0&#34; and &#34;S&#34;, respectively. Each label represents an input pin to the module. The module also has outputs 102, 112, 114, and 116, labeled &#34;B.3&#34;, &#34;B.2&#34;, &#34;B.1&#34;, and &#34;B.0&#34;, respectively Each labeled output represents an output pin on the module. Note that wire 102 represents both an input (A.3) and an output (B.3) which are directly connected within the module. This is another example of a feed-through pin from the internal perspective. In this case, the purpose of the feed-through pin is a logical convenience, rather than a graphical one. While the signals A.3 and B.3 are logically separate, they are physically the same. 
     The three instances 120, 130, and 140, of the multiplexer submodules are given the instance names &#34;M2&#34;, &#34;M1&#34;, and &#34;M0&#34;, respectively; and inverter 150 is given an instance name &#34;SEL.&#34; 
     FIG. 1b shows a graphical representation 200 of the module type (e.g., 0/1 bit shifter 100) of FIG. 1a, having four inputs 210 and one input 230 corresponding to the four module inputs 102, 104, 106 and 108, and the one select input 110. In similar manner, with respect to FIG. 1b, graphical module representation 200 also has four outputs 220 corresponding the four outputs 102, 112, 114, and 116 with respect to FIG. 1a. Because of the internal connection of signals A.3 and B.3 in FIG. 1a, two of these same signals in FIG. 1b are connected together physically, even though they are shown on the graphical representation as separate pins. The module type is given the name &#34;SHIFT1&#34;. 
     FIG. 1c shows a higher hierarchical schematic representation of a barrel shifter 300 comprising three instances, 305, 310, and 320, of the 0/1 bit shifter (100,200) of FIGS. 1a and 1b. Again with respect to FIG. 1c, shifter submodules 305 and 310 are interconnected by signals 370; shifter submodules 310 and 320 are interconnected by signals 380. The module has six inputs: four data inputs 330 labeled &#34;A.3&#34;, &#34;A.2&#34;, &#34;A.1&#34;, and &#34;A.0&#34;, and two shift select inputs 350 and 360 labeled &#34;R.0&#34; and &#34;R.1&#34;, respectively. The module also has four outputs 340 labeled &#34;Z.3&#34;, &#34;Z.2&#34;, &#34;Z.1&#34;, and &#34;Z.0&#34;. The three instances 305, 310, and 320 are given instance names &#34;F&#34;, &#34;G&#34;, and &#34;H&#34;, respectively. 
     FIG. 1d shows a graphical module representation for a module 400, which is the barrel shifter 300 of FIG. 1c. With respect to FIGS. 1c and 1d, inputs 410 correspond to inputs 330; inputs 430 and 440 correspond to inputs 360 and 350, respectively; and outputs 420 correspond to outputs 340. Note that while input A.3 and output Z.3 are shown as logically separate pins, they are connected together two levels of hierarchy below (FIG. 1a). The barrel shifter module 400 is given the name &#34;BARREL4&#34; in FIG. 1d. 
     FIG. 1e shows a lower hierarchical schematic representation of a module design 500 for a two input multiplexer, of which FIG. 1a shows three instances 120, 130, and 140. Again with respect to FIG. 1e, the module comprises four submodules: NAND gates 510, 520, and 530, and inverter 540. The NAND gate 510 is given an instance name of &#34;PICKA&#34;, the NAND gate 520 is given an instance name of &#34;PICKB&#34;, the NAND gate 530 is given an instance name of &#34;RES&#34;, and the inverter 540 is given an instance name of &#34;SN&#34;. Module inputs 550, 555, and 560 are labeled &#34;A&#34;, &#34;B&#34;, and &#34;S&#34;, respectively, and module outputs 575 and 560 are labeled &#34;Z&#34; and &#34;SF&#34;, respectively. Note that signal 560 is shown both as an input and an output, connecting two module pins together. This is a feed-through connection, as previously mentioned in the discussion of FIG. 1a. 
     FIG. 1f shows a graphical representation 600 of the module 500. With respect to FIGS. 1e and 1f, the graphical module representation 600 has an input 610 corresponding to input 550; an input 620 corresponding to input 555; an input 630 and feed-through pin 650 corresponding to signal 560, and an output 640 corresponding to output 575. 
     FIGS. 2a through 2d show a progressive logical decomposition of the hierarchical design of FIGS. 1a-1f starting at a high level and working down to a lower level bottom level. 
     FIG. 2a shows a schematic comprising a single graphical module representation 700 of a 4 bit barrel shifter having a module name of &#34;BARREL4&#34;, corresponding to the module 300 and 400 of FIGS. 1c and 1d, respectively. The represented module 700 has four data inputs 710 labeled &#34;A.3&#34;, &#34;A.2&#34;, &#34;A.1&#34;, and &#34;A.0&#34;, to which four wires have been connected labeled &#34;IN3&#34;, &#34;IN2&#34;, &#34;IN1&#34;, and &#34;IN0&#34;, respectively; four data outputs 720 labeled &#34;Z.3&#34;, &#34;Z.2&#34;, &#34;Z.1&#34;, and &#34;Z.0&#34; to which four wires have been connected labeled &#34;OUT3&#34;, &#34;OUT2&#34;, &#34;OUT1&#34;, and &#34;OUT0&#34;; and two shift count inputs 730 and 740 labeled &#34;R.1&#34; and &#34;R.0&#34;, respectively and to which two wires have been connected labeled &#34;SHF1&#34; and &#34;SHF0&#34;, respectively. 
     FIG. 2b shows a schematic representation 800 of the module 700, which has been flattened to the next lower hierarchical level where it can be seen that the equivalent circuit of BARREL4, 800, comprises three instances 850, 860 and 870 of a module named &#34;SHIFT1&#34;, corresponding to the module 100 and 200 of FIGS. 1a and 1b, respectively. Inputs 810 correspond to inputs 710 in FIG. 2a. Inputs 830 and 840 correspond to inputs 740 and 730 in FIG. 2a. Outputs 820 correspond to outputs 720 in FIG. 2a. Internal interconnections are made between module 850 and 860 by wires 880 and between modules 860 and 870 by wires 890. 
     FIG. 2c shows a further flattened representation 900 of the module 800 of FIG. 2b, one hierarchical level further down than shown in FIG. 2b. With respect to FIGS. 2b and 2c, SHIFT1 modules 850,860, and 870 are expanded to show their submodules and internal connections. Modules within dashed box 910 (i.e., 912, 914,916, and 918) represent SHIFT1 module 850. Modules 922, 924, 926, and 928 within dashed box 920 represent SHIFT1 module 860. Modules 932, 934, 936, and 938 within dashed box 930 represent SHIFT1 module 870. Inputs 940correspond to inputs 810; inputs 960 and 970 correspond to inputs 830 and 840, respectively; and outputs 950 correspond to outputs 820. Each SHIFT1 module comprises three multiplexers and one inverter, e.g., in the case of module 910 (corresponding to 850) the three multiplexers are represented by submodules 912, 914, and 916, and the inverter is represented by submodule 918. 
     FIG. 2d shows a further flattened representation 1000 of the module 800 of FIG. 2b (900 of FIG. 2c), at the bottom level of the hierarchy, comprising only primitives. With respect to FIGS. 2c and 2d, each multiplexer (i.e., 912, 914, 916, 922, 924, 926, 932, 934, and 936) is replaced with an expanded version (1000, 1015, 1030, 1005, 1020, 1035, 1010, 1025, and 1040, respectively) showing its submodules. Using module 912 as a typical example, module 912 is expanded into module 1000 comprising four submodules: 1001, 1002, 1003, and 1004. Inputs 1050 correspond to inputs 940; inputs 1080 and 1070 correspond to inputs 960 and 970, respectively; and outputs 1060 correspond to outputs 950. 
     For the following discussion of the present invention, it will be assumed that the hierarchical design of FIGS. 2a-2d has been captured on a ECAD system, and that all information relevant to the design has been loaded into the ECAD system&#39;s computer memory, including all module descriptions and interconnection data. While full detail may be available at any given step in the process, details will be shown only as they become relevant to the method of the present invention. 
     As mentioned hereinabove, the complete flattening process of the present invention comprises nine main steps: 
     Step 1. 
     In a first step, represented in FIG. 1g, a top-level module 1100 is created containing the entire hierarchical design, and having no input or output pins. This module will have a module type named &#34;TOP&#34; and an instance name of MAIN. Module type TOP subsumes the entire circuit representation of FIG. 2a, the original top-level schematic. It will also be assumed that the following module type names are in use: 
     
         ______________________________________Module TypesType Name    Description______________________________________IV:      Inverter (primitive)ND2:     2 Input NAND gate (primitive)MUX:     2 Input Multiplexer (ref. FIG. 1e,1f)SHIFT1:  0/1 bit Arithmetic Shifter (ref. FIG. 1a,1b)BARREL4: 4 bit Arithmetic Barrel Shifter (ref. FIG. 1c,1d)TOP      Top level module (ref. FIG. 1g)______________________________________ 
    
     It will also be assumed that the following instance names were used in each module type creation: 
     
         ______________________________________InstancesModule Type     Submodules   Submodule Instance Name______________________________________TOP       BARREL4      BarrelBARREL4   SHIFT1       F     SHIFT1       G     SHIFT1       HSHIFT1    IV           SEL (primitive)     MUX          M0     MUX          M1     MUX          M2MUX       IV           SN     ND2          PICKA     ND2          PICKB     ND2          RES______________________________________ 
    
     It will also be assumed that the following pin names are used for each of the module types: 
     
         ______________________________________Pin NamesModule             Pins______________________________________IV                 A, ZND2                A, B, ZMUX                A, B, S, SF, ZSHIFT1             A.3, A.2, A.1, A.0              S              B.3, B.2, B.1, B.0BARREL4            A.3, A.2, A.1, A.0              R.1, R.0              Z.3, Z.2, Z.1, Z.0TOP                none______________________________________ 
    
     Finally, it will be assumed that the following nets and net names exist by module type. Note that while some nets may be named by the user, the nets below will be assigned arbitrary sequential names without loss of generality (&#34;Pin:x&#34; refers to the module I/O pin named &#34;x&#34;, &#34;name:x&#34; refers to a pin named &#34;x&#34; of the submodule named &#34;name&#34; declared within the module type): 
     
         __________________________________________________________________________Nets and Net NamesModule Type   Net Name         Nets(wires)     FIG., Reference#__________________________________________________________________________IV      --    --ND2     --    --MUX     NA1   Pin:A, PICKA:A  FIG. 1e, 550   NA2   Pin:B, PICKB:A  FIG. 1e, 555   NA3   Pin:S, Pin:SF, PICKB:B, SN:A                         FIG. 1e, 560   NA4   Pin:Z, RES:Z    FIG. 1e, 575   NA5   SN:Z, PICKA:B   FIG. 1e, 580   NA6   PICKA:Z, RES:A  FIG. 1e, 565   NA7   PICKB:Z, RES:B  FIG. 1e, 570SHIFT1  NB1   Pin:A.3, Pin:B.3, M2:A                         FIG. la, 102   NB2   Pin:A.2, M2:B, M1:A                         FIG. 1a, 104   NB3   Pin:A.1, M1:B, M0:A                         FIG. la, 106   NB4   Pin:A.0, M0:B   FIG. 1a, 108   NB5   Pin:S, SEL:A    FIG. 1a, 110   NB6   Pin:B.2, M2:Z   FIG. 1a, 112   NB7   Pin:B.1, M1:Z   FIG. 1a, 114   NB8   Pin:B.0, M0:Z   FIG. 1a, 116   NB9   SEL:Z, M0:S     FIG. 1a, 160   NB10  M0:SF, M1:S     FIG. 1a, 165   NB11  M1:SF, M2:S     FIG. 1a, 170BARREL4 NC1   Pin:A.3, F:A.3  FIG. 1c, 330   NC2   Pin:A.2, F:A.2  FIG. 1c, 330   NC3   Pin:A.1, F:A.1  FIG. 1c, 330   NC4   Pin:A.0, F:A.0  FIG. 1c, 330   NC5   Pin:R.0, F:S    FIG. 1c, 350   NC6   Pin:R.1, G:S, H:S                         FIG. 1c, 360   NC7   Pin:Z.3, H:B.3  FIG. 1c, 340   NC8   Pin:Z.2, H:B.2  FIG. 1c, 340   NC9   Pin:Z.1, H:B.1  FIG. 1c, 340   NC10  Pin:Z.0, H:Z.0  FIG. 1c, 340   NC11  F:B.3, G:A.3    FIG. 1c, 370   NC12  F:B.2, G:A.2    FIG. 1c, 370   NC13  F:B.1, G:A.1    FIG. 1c, 370   NC14  F:B.0, G:A.0    FIG. 1c, 370   NC15  G:B.3, H:A.3    FIG. 1c, 380   NC16  G:B.2, H:A.2    FIG. 1c, 380   NC17  G:B.1, H:A.1    FIG. 1c, 380   NC18  G:B.0, H:A.0    FIG. 1c, 380TOP     ND1   IN3, BARREL:A.3 FIG. 2a, 710   ND2   IN2, BARREL:A.2 FIG. 2a, 710   ND3   IN1, BARREL:A.1 FIG. 2a, 710   ND4   IN0, BARREL:A.0 FIG. 2a, 710   ND5   SHF1, BARREL:R.1                         FIG. 2a, 730   ND6   SHF0, BARREL:R.0                         FIG. 2a, 740   ND7   OUT3, BARREL:Z.3                         FIG. 2a, 720   ND8   OUT2, BARREL:Z.2                         FIG. 2a, 720   ND9   OUT1, BARREL:Z.1                         FIG. 2a, 720   ND10  OUT0, BARREL:Z.0                         FIG. 2a, 720__________________________________________________________________________ 
    
     It should be noted that all nets are consistent with FIGS. 1a, 1c, and 1e. Nets with a &#34;Pin:x&#34; specification in their list of connections are external nets, because they connect to I/O pins of the module; and nets without a &#34;Pin:x&#34; specification are internal nets, because they are not visible at a higher level. Nets having two or more &#34;Pin:x&#34; specifications represent feed-throughs, and will be examined in step six of the method of the present invention, described in greater detail hereinbelow. 
     Step 2. 
     In this step, the entire hierarchy is scanned from top to bottom to determine the level of each type. After this process is complete, the following level assignments will have been made, and recorded. 
     
         ______________________________________Level Assignments  Type           Level______________________________________  TOP            4  SHIFT1         2  MUX            1  IV             0  BARREL4        3  ND2            0______________________________________ 
    
     No module type is examined more than once. A standard algorithm for levelizing a combinational logic circuit is adapted for this purpose. To find the level of a module, one first finds the level of all module types used in the module for which the level is not yet known. One then takes the largest level of any type used in the module, and adds ONE, giving the level of the module. In this case, it runs as follows: 
     
         ______________________________________start on TOPstart on BARREL4  start on SHIFT1    start on IV→primitive,∴0    start on MUX      IV already computed to be 0      start on ND2→primitive,∴0    max is 0 ∴ MUX level = 1  max is 1 ∴ SHIFT1 level =2max is 2 ∴ BARREL4 level =3max is 3 ∴ TOP level =4______________________________________ 
    
     In general, analysis of a module type&#39;s level in a hierarchy will be determined in the order that module types are encountered (declared) in the hierarchy, which may or may not be related to its level in the hierarchy. In the case shown above, the order of declaration is not related to hierarchical level. 
     Step 3. 
     In this step, all module type descriptions are placed into a list sorted in order of increasing hierarchical level as assigned in Step 2. (The order of module type descriptions in the list at the same hierarchical level is unimportant.) After the third step, the module type descriptions for this example are placed in a list in the following order: 
     
         ______________________________________Module Description List 1  Module         Level______________________________________  IV             0  ND2            0  MUX            1  SHIFT1         2  BARREL4        3  TOP            4______________________________________ 
    
     Each module type appears only once in the list. Each entry therefore has no specific instance name or parent. 
     Step 4. 
     In this step, the pin connection orders are standardized for all modules of the same type. For example, in the process of creating the design, and depending upon specific data structure creation techniques used by a specific ECAD system, connection lists for module descriptions may be ordered in a haphazard fashion or may have pins referred to by two or more different methods. It is necessary to standardize the order of entry by pin for each module of the same type and to eliminate redundant entries. After the completion of this process, pin orders (which have been arbitrarily chosen for this example) will be as follows (a &#34;parent&#34; is the module type to which a submodule belongs): 
     
         ______________________________________Module Description List 2Inst     Type       Level     Parent   Pins______________________________________SN       IV         1         MUX                                  A                                  ZPICKA    ND2        1         MUX                                  A                                  B                                  ZPICKB    ND2        1         MUX                                  A                                  B                                  ZRES      ND2        1         MUX                                  A                                  B                                  ZSEL      IV         2         SHIFT1                                  A                                  ZM0       MUX        2         SHIFT1                                  A                                  B                                  S                                  SF                                  ZM1       MUX        2         SHIFT1                                  A                                  B                                  S                                  SF                                  ZM2       MUX        2         SHIFT1                                  A                                  B                                  S                                  SF                                  ZF        SHIFT1     3         BARREL4                                  A.3                                  A.2                                  A.1                                  A.0                                  S.                                  B.3                                  B.2                                  B.1                                  B.0G        SHIFT1     3         BARREL4                                  A.3                                  A.2                                  A.1                                  A.0                                  S                                  B.3                                  B.2                                  B.1                                  B.0H        SHIFT1     3         BARREL4                                  A.3                                  A.2                                  A.1                                  A.0                                  S                                  B.3                                  B.2                                  B.1                                  B.0BARREL   BARREL4    4         TOP                                  A.3                                  A.2                                  A.1                                  A.0                                  R.1                                  R.0                                  Z.3                                  Z.2                                  Z.1                                  Z.0MAIN     TOP        none      none                                  none______________________________________ 
    
     This operation is done one parent at a time, in order of the parent&#39;s level (rather than in order of the submodule&#39;s level). 
     As illustrated above, the order of pins for modules of the same type is identical. 
     Step 5. 
     In this step, all global references in the module description list are resolved. That is, any global signal used by a submodule is moved up the hierarchy and added to the list of global signals used by the module containing it (its &#34;parent&#34; module), if it is not already in the list. The hierarchy is processed from bottom to top (i.e., level 0 up) so that at the end, any module&#39;s global signal list will reflect all of the global signals in use by all of its submodules. (This example does not use any global signals.) The module description list will contain the following after this step: 
     
         ______________________________________Module Description List 3Module           Level       Pins______________________________________IV               0                        A                        ZND2              0                        A                        B                        ZMUX              1                        A                        B                        S                        SF                        ZSHIFT1           2                        A.3                        A.2                        A.1                        A.0                        S                        B.3                        B.2                        B.1                        B.0BARREL4          3                        A.3                        A.2                        A.1                        A.0                        R.1                        R.0                        Z.3                        Z.2                        Z.1                        Z.0TOP              4                        none______________________________________ 
    
     Step 6. 
     In this step, the net list (wire list) is now altered according to detection of internal nets of submodules which connect two pins together (i.e., feed-throughs). Feed-throughs are eliminated by deleting all but one of the &#34;shorted&#34; wires at the higher level and moving all connections of the deleted wires to the remaining wire, less the redundant pin connection. In like manner, global connections are passed up the hierarchy such that at the end of this step, each submodule pin and global connection is associated with an internal or external wire or global reference. The resultant altered net-list will contain the following information. (offsets are specified within the submodule description, for all internal nets): 
     
         ______________________________________Altered Net-ListType    Name     Offset  Nets(wires)______________________________________IV      --       --      none (primitive)ND2     --       --      none (primitive)MUX     NA1              Pin:A, PICKA:A   NA2              Pin:B, PICKB:A   NA3              Pin:S, Pin:SF, PICKB:B, SN:A   NA4              Pin:Z, RES:Z   NA5      0       SN:Z, PICKA:B   NA6      1       PICKA:Z, RES:A   NA7      2       PICKB:Z, RES:BSHIFT1  NB1              Pin:A.3, Pin:B.3, M2:A   NB2              Pin:A.2, M2:B, M1:A   NB3              Pin:A.1, M1:B, M0:A   NB4              Pin:A.0, M0:B   NB5              Pin:S, SEL:A   NB6              Pin:B.2, M2:Z   NB7              Pin:B.1, M1:Z   NB8              Pin:B.0, M0:Z   NB9      0       SEL:Z, M0:S, M1:S, M2:SBARREL4 NC1              Pin:A.3, Pin:Z.3, F:A.3, G:A.3,                    H:A.3   NC2              Pin:A.2, F:A.2   NC3              Pin:A.1, F:A.1   NC4              Pin:A.0, F:A.0   NC5              Pin:R.0, F:S   NC6              Pin:R.1, G:S, H:S   NC8              Pin:Z.2, H:B.2   NC9              Pin:Z.1, H:B.1   NC10             Pin:Z.0, H:Z.0   NC12     0       F:B.2, G:A.2   NC13     1       F:B.1, G:A.1   NC14     2       F:B.0, G:A.0   NC16     3       G:B.2, H:A.2   NC17     4       G:B.1, H:A.1   NC18     5       G:B.0, H:A.0TOP     ND1      0       IN3, OUT3, BARREL:A.3   ND2      1       IN2, BARREL:A.2   ND3      2       IN1, BARREL:A.1   ND4      3       IN0, BARREL:A.0   ND5      4       SHF1, BARREL:R.1   ND6      5       SHF0, BARREL:R.0   ND8      6       OUT2, BARREL:Z.2   ND9      7       OUT1, BARREL:Z.1   ND10     8       OUT0, BARREL:Z.0______________________________________ 
    
     As shown, alterations have been made to SHIFT1, BARREL4 and TOP net lists to account for feed-through connections (specifically, elimination of nets NB10, NB11, NC7, NC11, NC15, and ND7), and the associated elimination of redundant pin connections (specifically, elimination of MUX:SF, SHIFT1:B.3, and BARREL4:Z.3 pin connections). 
     Step 6, in which pins and internal wires that are connected together are identified, is the most complex step in the flattening method of the present invention. Its basic purpose is to produce a list of internal and external wires for each module type, and to specify which of these wires is connected to each I/O pin and subcomponent pin. If the ECAD system did not allow two or more I/O pins of a module type to be wired together inside that module, this step would be less significant, but such a restriction would be a serious weakness in the ECAD system. This is to be distinguished from the case in which two pins are wired together in an enclosing module. That case is also handled by Step 6, when it operates on the enclosing module. In this discussion, references to I/O pins of a subcomponent should be understood to also include global signals accessed by the subcomponent from definitions in the current module or higher level modules. Since whether two pins of a module are wired together can depend on whether two pins of one of its subcomponents are wired together, it is important to run Step 6 on all of the subcomponent types used in a module type before working on that module type. This is guaranteed by running it on all module types at one hierarchical level prior running it on module types at the next higher level. 
     In this example, by way of preferred embodiment of the invention, Step 6 consists of performing the following steps 6(a) . . . (k) on each module type. 
     (a) Count the wires in the module description. Create an array of integers (named &#34;INDICES&#34;) with that many elements. Set each element of the array to its own position in the array (i.e., element zero is set to zero, element one is set to one, etc.). 
     (b) Count the I/O pins of each subcomponent. Attach that number to the record for the subcomponent. Add up the numbers to find the total number of connections to subcomponents. Create an array of integers (named &#34;PINS&#34;) with that many elements. Set all of the elements to -1. 
     (c) For each I/O pin of each subcomponent, find the wire in the module description that it is connected to, allocate a position in the PINS array, and store the ID number of the wire into the allocated position in the pin array. The ID number of the wire is simply its position in the module description&#39;s list of wires. The module description specifies to which wire each subcomponent I/O pin is connected. 
     (d) One of the results of performing these steps (6a-6k) on a module type is a table which specifies which I/O pins are wired together inside that module. This table is in the form of an array of integers (named &#34;IOS&#34;), with one entry for each I/O pin. The number in the array position for a given I/O pin is the same as the position in the array, unless that I/O pin is wired to another pin of the same module. If it is wired to such a pin, the number in its array position is the position of that pin. If three or more pins are wired together, their positions in the IOS array are linked in a circular list. 
     For each I/O pin of each subcomponent, its position is found in the IOS array of the module type of the subcomponent. (This table has been created already because the module types are processed in the correct order.) If the number in that position in the IOS array is not equal to the position, the pins corresponding to the position and the number found in the position are wired together. The ID numbers of the signals connected to the two pins are looked up in the PINS array. The ID number of one is placed in the position corresponding to the other in the INDICES array. This assumes that neither signal has already had this function performed on it--if it has, the operation is more complex. The purpose of this is that the INDICES array maps all signals that have been wired together to a single signal. 
     (e) At this point, all signals wired together can be traced to a common signal through the INDICES array by repeatedly going from a given position to the position specified at that position in the array until a position containing its own index is found. This step modifies the INDICES array so that this can be done for each signal in one step, instead of in several steps. Hence, for example, if signals &#34;1&#34;, &#34;2&#34; and &#34;3&#34; are wired together, the INDICES array will contain the same number (e.g. &#34;1&#34;) in all three positions. 
     (f) There will now be a unique number for each electrically connected set of wires. These numbers are copied into the PINS array elements so that each subcomponent I/O pin points at the wire to which it is connected. The numbers are also copied into the module description wire list, so that each wire&#39;s ID number is changed to that of the different wire it is connected to, if any. 
     (g) There will now be two types of wires: those that are marked as equivalent to another wire, and those that are not. Exactly one wire in a group of equivalent wires is not so marked, and the others in the group point to it. An unmarked wire is recognized by having its own position in its position in the INDICES array. These wires are counted. The result is the number of distinct internal and external wires in the module. These wires are then renumbered, starting at zero. The marked wires are ignored from this point onward. The wire ID numbers and the elements of the PINS array are changed again to reflect the renumbering. At this point, the information in the INDICES array is no longer important. It is now cleared by filling each element with -1. 
     (h) An IOS array like the ones used in Step 6(d), above, is now created for the current module. It will be used when Step 6(d) is run on higher level modules. It is an array of integers with one element for each I/O pin of the module. All elements are initialized to -1. 
     (i) The pin number of each module I/O pin is inserted in the INDICES array in the position specified by the ID number of the wire to which that I/O pin is connected. If two or more I/O pins are connected to the same wire, the INDICES array element contains the pin number of the first one. The IOS array elements at the positions corresponding to all of the module I/O pins connected to the same wire are linked together in a circular chain. For example, if pins &#34;2&#34;, &#34;3&#34; and &#34;5&#34; are all connected to wire &#34;6&#34;, IOS[2]=5, IOS[5]=3, and IOS[3]=2. As each pin is processed, the INDICES array element of the wire connected to that pin is used to find any other pins that are also connected to that wire. 
     (j) The INDICES array now contains a value of -1 for all internal wires and the I/O pin number of a pin for all external wires. The internal wires are counted, and the INDICES array is stepped through, setting the elements for internal wires to successive positive integers and adding a large constant such as one billion to the elements for external wires. This step allocates relative positions to all of the internal wires of the module. The large constant is added simply so that external wires can still be distinguished from internal wires, by having numbers greater to or equal to that of the constant. (It is assumed that no module has more than one billion internal wires.) 
     (k) The change to the INDICES array performed in Step 6(j) constitutes another renumbering of the module&#39;s wires. The new numbering must again be propagated to the wire ID numbers and to the PINS array. The PINS array will now contain the information needed in Step 9 (below) to connect instantiated subcomponent pins to the correct instantiated wires. The PINS array is saved in the module description data structure. 
     Step 7. 
     In this step, the number of internal wires (internal signals), submodules, and submodule pins directly or indirectly contained in each module type is counted (computed). Totalizing is based on the previous analysis. This is all accomplished by traversing the hierarchy of module types from bottom to top. The process is illustrated in the table, below, and also in FIG. 3. The results are as follows, in order of calculation. 
     In FIG. 3, there is shown a &#34;reduced&#34; hierarchical arrangement 1200 of the Barrel Shifter described in FIGS. 1a-f and 2a-e. Various &#34;bookkeeping&#34; numbers n1 . . . n7 are shown. The numbers n1 . . . n4 relate to current &#34;counts&#34; for the present module (direct), and the numbers n5 . . . n7 relate to cumulative totals for the present module and all lower modules (direct and indirect). More particularly: 
     n1 is the number of pins in a module (direct); 
     n2 is the number of internal signals in the module (direct); 
     n3 is the number of submodules contained in the module (direct); 
     n4 is the number of submodule pins contained in the module (direct); 
     n5 is the cumulative total of submodules contained in the module (direct and indirect); 
     n6 is the cumulative total of submodule pins (direct and indirect); and 
     n7 is the cumulative total of internal signals (direct and indirect). 
     &#34;n1&#34; through &#34;n4&#34; are computed in Step 6. &#34;n5&#34; through &#34;n7&#34; are computed in Step 7 on the basis of &#34;n1&#34; through &#34;n3&#34;. &#34;n4&#34; is the size of the PINS array created in Step 6, and is not used in Step 7. 
     There are two &#34;primitives&#34; at level 0--an IV 1202 (corresponding to the inverter 540 of FIG. 1e and 150 of FIG. 1a) and a NAND gate 1204 (corresponding to the NAND gates 510, 520 and 530 of FIG. 1e). 
     The inverter 1202 is a module, and has two pins--named &#34;A&#34; and &#34;Z&#34;. The module 1202 has the following module &#34;counts&#34;, n1 . . . n4: n1=2 pins, n2=0 internal signals (it is a primitive), contains n3=0 submodules, and has n4=0 submodule pins. 
     The cumulative totals n5-n7 at this stage are: n5=0 submodules; n6=2 pins (direct) and submodule pins (indirect); and n7=0 internal wires (direct and indirect). Evidently, n5=n3, n6=n1, and n7=n2, at this stage. 
     Moving to the next level of the reduced hierarchical arrangement, at level 0 there is also a NAND gate 1204, which has module counts of: n1=3 pins--named &#34;A&#34;, &#34;B&#34; and &#34;Z&#34;; n2=0 internal signals; n3=0 submodules; and n4=0 submodule pins. 
     The cumulative totals at this stage are: n5=0 submodules; n6=3 submodule pins; and n7=0 internal wires. Evidently, n5=n3, n6=n1, and n7=n2, at this stage. 
     At level 1, there appears a MUX module 1206. From FIG. 1a, we know that there will be three instances of MUX (M2, M1, M0) for each SHIFT1, and from FIG. 1c we know that there will be three instances of SHIFT1 (for the BARREL module). For MUX 1206, there are: n1=5 pins (A,B,S,SF,Z); n2=3 internal signals (SN/Z, PICKA/Z, PICKB/Z); n3=4 submodules (PICKA, PICKB, RES, SN, see FIG. 1e); and n4=11 submodule pins. 
     The cumulative totals at the level of the MUX 1206 are: n5=4 submodules; n6=16 submodule pins; and n7=3 internal wires. 
     At level 2, there appears a SHIFT1 module 1208. From FIGS. 1a and 1e we know that each instance of SHIFT1 contains four submodules (M2, M1, M0, SEL). For SHIFT1, there are: n1=9 pins (A3, A2, A1, A0, S, B3, B2, B1, B0); n2=1 internal signals; n3=4 submodules (SEL,M0,M1,M2); and n4=17 submodule pins. 
     The cumulative totals at this level (present module) are: n5=16, n6=59 and n7=10. 
     At level 3, showing the BARREL module 1210 (see 400, FIG. 1d), the counts are: n1=10, n2=6, n3=3 and n4=27. The cumulative totals (present module) are: n5=51, n6=187 and n7=36, calculated as follows: 
     
         n5(present module)=[n5(SHIFT1 submodule)·3 instances+n3(present module)]; 
    
     
         n6(present module)=[n6(SHIFT1 submodule)×3 instances+n1(present module); and 
    
     
         n7(present module)=[n7(SHIFT1 submodule)×3 instances+n2(present module). 
    
     At level 4 is the TOP module 1212, which was created in step 1 (see FIG. 1g). The counts are: n1=0 (by definition), n2=9, n3=1, and n4=10. The cumulative totals (present module) are: n5=52 (n5,submodule, plus n3, present), n6=187 (same as n6, submodule) and n7=45 (n7, submodule, plus n2, present). 
     The &#34;Counts and Totals&#34; table, below, and FIG. 3 present the counts and totals. 
     Thus, it can be seen, in the reduced hierarchical arrangement, that: 
     
         ______________________________________Counts and TotalsLevel     n1     n2     n3    n4   n5   n6    n7______________________________________0 (IV)    2      0      0     0    0    2     00 (ND2)   3      0      0     0    0    3     01 (MUX)   5      3      4     11   4    16    32 (SHIFT1)     9      1      4     17   16   59    103 (BARREL)     10     6      3     27   51   187   364 (TOP)   0      9      1     10   52   187   45______________________________________ 
    
     The counts n5, n6 and n7 are calculated by starting them at n3, n1 and n2, respectively, and then looping over all submodules of the present module, and adding in their values for n5, n6 and n7. At each subcomponent, there therefore exists the partial sum for n5, n6 and n7 that does not yet include the current submodule or those after it. These partial sums are written to the record for each subcomponent. They are the offsets that specify the relative location of each item in the final flat design. 
     The partial sums are shown for the SHIFT1 module in FIG. 3. The partial sums for n5 are 4, 4, 8 and 12. For n6 they are 9, 11, 27 and 43. For n7 they are 1, 1, 4 and 7. For the sake of a procedural simplification in Step 9, it is most convenient to base the n5 partial sums starting at the relative positions of the submodules they are attached to. Therefore, successive integers are subtracted from those values. So the actual offsets are 4-0=4, 4-1=3, 8-2=6 and 12-3=9. This transformation does not apply to the n6 and n7 values. 
     The counting and totaling in this step is the key to pre-planning memory allocation for the flattened representation (Step 8), and to placement of instances in the flattened representation (Step 9). 
     Step 8. 
     In this step, memory is allocated for a flattened data structure to be created which will include arrays of module instances, pin instances, and wire instances. In Step 7, above, appropriate counts were provided for each array element type (i.e., module instance, pin instance, and wire instance). In the calculations for module &#34;TOP&#34;, these counts need only be multiplied by the known allocation size for each array element type and added together to get the total size of the memory allocation required. 
     Memory can be allocated in one large block or in three blocks, one block for each array. The difference between one segment and three is very small. However, the difference between one (or three) segments and several thousand segments can make a noticeable difference in the execution time. 
     Step 9. 
     In this step, the circuit is flattened by the recursive algorithm described hereinabove. The resulting instance arrays will contain the following information (Module instance array is shown hierarchically as a notational convenience; actual array is linear, number at left indicates actual array index): 
     
         ______________________________________Module Instance ArrayNo.  Instance(s)______________________________________0:   BARREL.11:     F.1     G.1    H.14:       SEL.1   M0.1    M1.1 M2.1 .sub.(submodules of F)8:         SN.1.1  PICKA.1.1 PICKB.1.1                                RES.1.112:        SN.1.2  PICKA.1.2 PICKB.1.2                                RES.1.216:        SN.1.3  PICKA.1.3 PICKB.1.3                                RES.1.320:      SEL.2   M0.2    M1.2 M2.2 .sub.(submodules of G)24:        SN.2.1  PICKA.2.1 PICKB.2.1                                RES.2.128:        SN.2.2  PICKA.2.2 PICKB.2.2                                RES.2.232:        SN.2.3  PICKA.2.3 PICKB.2.3                                RES.2.336:      SEL.3   M0.3    M1.3 M2.3 .sub.(submodules of H)40:        SN.3.1  PICKA.3.1 PICKB.3.1                                RES.3.144:        SN.3.2  PICKA.3.2 PICKB.3.2                                RES.3.248:        SN.3.3  PICKA.3.3 PICKB.3.3                                RES.3.3______________________________________Internal Wire Instance ArrayNo:     Connections______________________________________0       IN3, OUT3, BARREL.1:A.3,                        *TOP*   BARREL.1:Z.31       IN2, BARREL.1:A.22       IN1, BARREL.1:A.13       IN0, BARREL.1:A.04       SHF1, BARREL.1:R.15       SHF0, BARREL.1:R.06       OUT2, BARREL.1:Z.27       OUT1, BARREL.1:Z.18       OUT0, BARREL.1:Z.09       F.l:B.2, G.1:A.2     *BARREL.1*10      F.1:B.1, G.1:A.111      F.1:B.0, G.1:A.012      G.1:B.2, H.1:A.213      G.1:B.1, H.1:A.114      G.1:B.0, H.1:A.015      SEL.1:Z, M0.1:S, M1.1:S, M2.1:S                        *F.1*16      SN.1.1:Z, PICKA.1.1:B                        *M0.1*17      PICKA.1.1:Z, RES.1.1:A18      PICKB.1.1:Z, RES.1.1:B19      SN.1.2:Z, PICKA.1.2:B                        *M1.1*20      PICKA.1.2:Z, RES.1.2:A21      PICKB.1.2:Z, RES.1.2:B22      SN.1.3:Z, PICKA.1.3:B                        *M2.1*23      PICKA.1.3:Z, RES.1.3:A24      PICKB.1.3:Z, RES.1.3:B25      SEL.2:Z, M0.2:S, M1.2:S, M2.2:S                        *G.1*26      SN.2.1:Z, PICKA.2.1:B                        *M0.2*27      PICKA.2.1:Z, RES.2.1:A28      PICKB.2.1:Z, RES.2.1:B29      SN.2.2:Z, PICKA.2.2:B                        *M1.2*30      PICKA.2.2:Z, RES.2.2:A31      PICKB.2.2:Z, RES.2.2:B32      SN.2.3:Z, PICKA.2.3:B                        *M2.2*33      PICKA.2.3:Z, RES.2.3:A34      PICKB.2.3:Z, RES.2.3:B35      SEL.3:Z, M0.3:S, M1.3:S, M2.3:S                        *H.1*36      SN.3.1:Z, PICKA.3.1:B                        *M0.3*37      PICKA.3.1:Z, RES.3.1:A38      PICKB.3.1:Z, RES.3.1:B39      SN.3.2:Z, PICKA.3.2:B                        *M1.3*40      PICKA.3.2:Z, RES.3.2:A41      PICKB.3.2:Z, RES.3.2:B42      SN.3.3:Z, PICKA.3.3:B                        *M2.3*43      PICYA.3.3:Z, RES.3.3:A44      PICKB.3.3:Z, RES.3.3:B______________________________________Pin Instance ArrayNo:        Parent       Name       Wire______________________________________0          BARREL.1     A.3        01          BARREL.1     A.2        12          BARREL.1     A.1        23          BARREL.1     A.0        34          BARREL.1     R.1        45          BARREL.1     R.0        56          BARREL.1     Z.3        07          BARREL.1     Z.2        68          BARREL.1     Z.1        79          BARREL.1     Z.0        810         F.1          A.3        011         F.1          A.2        112         F.1          A.1        213         F.1          A.0        314         F.1          S          515         F.1          B.3        016         F.1          B.2        917         F.1          B.1        1018         F.1          B.0        1119         G.1          A.3        020         G.1          A.2        921         G.1          A.1        1022         G.1          A.0        1123         G.1          S          424         G.1          B.3        025         G.1          B.2        1226         G.1          B.1        1327         G.1          B.0        1428         H.1          A.3        029         H.1          A.2        1230         H.1          A.1        1331         H.1          A.0        1432         H.1          S          433         H.1          B.3        034         H.1          B.2        635         H.1          B.1        736         H.1          B.0        837         SEL.1        A          538         SEL.1        Z          1539         M0.1         A          240         M0.1         B          341         M0.1         S          1542         M0.1         SF         1543         M0.1         Z          1144         M1.1         A          145         M1.1         B          246         M1.1         S          1547         M1.1         SF         1548         M1.1         Z          1049         M2.1         A          050         M2.1         B          151         M2.1         S          1552         M2.1         SF         1553         M2.1         Z          954         SN.1.1       A          1555         SN.1.1       Z          1656         PICKA.1.1    A          247         PICKA.1.1    B          1658         PICKA.1.1    Z          1759         PICKB.1.1    A          360         PICKB.1.1    B          1561         PICKB.1.1    Z          1862         RES.1.1      A          1763         RES.1.1      B          1864         RES.1.1      Z          1165         SN.1.2       A          1566         SN.1.2       Z          1967         PICKA.1.2    A          168         PICKA.1.2    B          1969         PICKA.1.2    Z          2070         PICKB.1.2    A          271         PICKB.1.2    B          1572         PICKB.1.2    Z          2173         RES.1.2      A          2074         RES.1.2      B          2175         RES.1.2      Z          1076         SN.1.3       A          1577         SN.1.3       Z          2278         PICKA.1.3    A          079         PICKA.1.3    B          2280         PICKA.1.3    Z          2381         PICKB.1.3    A          182         PICKB.1.3    B          1583         PICKB.1.3    Z          2484         RES.1.3      A          2385         RES.1.3      B          2486         RES.1.3      Z          987         SEL.2        A          488         SEL.2        Z          25      etc . . .______________________________________ 
    
     The remainder of the wire instance table continues on in similar fashion. 
     FIG. 4 is a data diagram representing the structure of the flattened design, corresponding to the first two tables of instance arrays set forth above. (The pin instance array was omitted because of its size.) 
     While it is possible to simply flatten the structure, eliminating any and all traces of hierarchy and reducing the design to a group of interconnected primitives, this would eliminate much traceback information which is essential to the designer in relating primitives to their original place in the hierarchy. Without this information, another means of on-line cross-referencing of the flat structure and the hierarchy would be required. In the sample design, this would amount to discarding FIGS. 2a-2c, and keeping only FIG. 2d. 
     In the present invention, the hierarchical history is preserved. 
     It is possible to transform the recursive flattening routing into an equivalent non-recursive routine by standard program transformation techniques. This would make the routine slightly faster, but the code would be harder to understand. 
     The invention has been described in the context of an electronic circuit, but is more broadly applicable to the flattening of any hierarchical structure. In general terms, a hierarchical design including a plurality of modules, submodules and primitives is methodically rearranged, and a top-level module is created. Attributes for each module, submodule and primitive are re-ordered in a consistent manner, and certain parameters are propagated up to the top-level module. The attributes for each module, submodule and primitive are counted, and totalized from the bottom up. Partial sums are attached to each submodule to record its relative position in the flat structure. Based on the totalized attribute count, memory is allocated prior to flattening. A flattening routine is applied recursively to the design. This routine uses the information computed in earlier steps to simplify operations performed on each component of the flat structure, thus allowing the flattening algorithm to run very quickly. 
     APPENDIX 
     Appended hereto, and forming part of the disclosure, is a 22 page document including code listing and comments. ##SPC1##