Patent Publication Number: US-6223142-B1

Title: Method and system for incrementally compiling instrumentation into a simulation model

Description:
CROSS REFERENCE TO RELATED APPLICATIONS 
     The present application is related to the following copending U.S. patent applications: U.S. patent application Ser. No. 09/190,865 (Docket No. AT9-98-149) filed on Nov. 9, 1998, titled “Method And System For Instrumenting Simulation Models”; U.S. patent application Ser. No. 9/190,862 (Docket No. AT9-98-151) filed on Nov. 9, 1998, titled “Automatic Adjustment For Counting Instrumentation”; U.S. patent application Ser. No. 09/190,863 (Docket No. AT9-98-152) filed on Nov. 9, 1998, titled “Hardware Simulator Instrumentation”; and U.S. patent application Ser. No. 09/190,864 (Docket No. AT9-98-153) filed on Nov. 9, 1998, titled “Method And System For Selectively Disabling Simulation Model Instrumentation”. The above mentioned patent applications are assigned to the assignee of the present invention. The content of the cross referenced copending applications are hereby incorporated herein by reference thereto. 
     BACKGROUND OF THE INVENTION 
     1. Technical Field 
     The present invention relates in general to a method and system for interactively designing and simulating complex circuits and systems, particularly digital devices, modules and systems. In particular, the present invention relates to a method and system for efficiently simulating and verifying the logical correctness of complex digital circuit designs. More particularly, the present invention relates to a method and system that improve the model build and simulation processes in order to allow a designer to easily instrument and monitor a simulation model. Still more particularly, the present invention relates to a method and system that utilize instrumentation modules written in hardware description language to monitor the operation of computer-generated digital circuit designs. 
     2. Description of the Related Art 
     Verifying the logical correctness of a digital design and debugging the design, if necessary, are very important steps in most digital design processes. Logic networks are tested either by actually building networks or by simulating networks on a computer. As logic networks become highly complex, it becomes necessary to simulate a design before the design is actually built. This is especially true when the design is implemented as an integrated circuit, since the fabrication of integrated circuits requires considerable time and correction of mistakes is quite costly. The goal of digital design simulation is the verification of the logical correctness of the design. 
     In a typical automated design process that is supported by a conventional electronic computer-aided design (ECAD) system, a designer enters a high-level description utilizing a hardware description language (HDL), such as VHDL, producing a representation of the various circuit blocks and their interconnections. The ECAD system compiles the design description into a format that is best suited for simulation. A simulator is then utilized to verify the logical correctness of the design prior to developing a circuit layout. 
     A simulator is typically a software tool that operates on a digital representation, or simulation model of a circuit, and a list of input stimuli representing inputs of the digital system. A simulator generates a numerical representation of the response of the circuit which may then either be viewed on the display screen as a list of values or further interpreted, often by a separate software program, and presented on the display screen in graphical form. The simulator may be run either on a general purpose computer or on another piece of electronic apparatus specially designed for simulation. Simulators that run entirely in software on a general purpose computer will hereinafter be referred to as “software simulators”. Simulators that are run with the assistance of specially designed electronic apparatus will hereinafter be referred to as “hardware simulators”. 
     Usually, software simulators perform a very large number of calculations and operate slowly from the user&#39;s point of view. In order to optimize performance, the format of the simulation model is designed for very efficient use by the simulator. Hardware simulators, by nature, require that the simulation model comprising the circuit description be communicated in a specially designed format. In either case, a translation from an HDL description to a simulation format, hereinafter referred to as a simulation executable model, is required. 
     Simulation has become a very costly and time-consuming segment of the overall design process as designs become increasingly complex. Therefore, great expense is invested to ensure the highest possible accuracy and efficiency in the processes utilized to verify digital designs. A useful method of addressing design complexity is to simulate digital designs at several levels of abstraction. At the functional level, system operation is described in terms of a sequence of transactions between registers, adders, memories and other functional units. Simulation at the functional level is utilized to verify the high-level design of high-level systems. 
     At the logical level, a digital system is described in terms of logic elements such as logic gates and flip-flops. Simulation at the logic level is utilized to verify the correctness of the logic design. At the circuit level, each logic gate is described in terms of its circuit components such as transistors, impedences, capacitances, and other such devices. Simulation at the circuit level provides detailed information about voltage levels and switching speeds. 
     VHDL is a higher level language for describing the hardware design of complex devices. The overall circuit design is frequently divided into smaller parts, hereinafter referred to as design entities, that are individually designed, often by different design engineers, and then combined in a hierarchical manner to create an overall model. This hierarchical design technique is very useful in managing the enormous complexity of the overall design. Another advantage of this approach is that errors in a design entity are easier to detect when that entity is simulated in isolation. 
     A problem arises however when the overall model is simulated as a whole. Compound errors may occur which mask other individual errors. Further, the enormity of modern digital design complexity makes the errors in each design entity difficult to recognize. Therefore, although the hierarchical nature of VHDL eases the development and modeling phases of complex designs, problems with obtaining accurate and comprehensive simulation test results of the overall design remain unresolved. 
     Therefore, there is a need to accurately monitor characteristics of specific modules or submodules of a large scale design in order to more efficiently and accurately diagnose problems with and assess the correctness of the overall design. 
     A current method of verifying large scale design models is to integrate programs written in high level languages such as C or C++ into the overall HDL design flow. Often, one or more custom-developed programs written in a high-level programming language are incorporated into the verification strategy as follows. The high level-language program or programs, hereinafter referred to as a reference model, are written to process test vectors to produce expected results. The reference model supplies the “expected correct result” of any given simulation run. The test vector is then run on the simulation execution model by the simulator. The results of the simulation run are then compared to the results predicted by the reference model. Discrepancies are flagged as errors. Such a simulation check is known by those skilled in the art as an “end-to-end” check. This method of “end-to-end” checking has two problems. First, the problem of masking of internal logic failures remains as these errors may not propagate to the final results of the circuit checked in an end-to-end test. Second, an end-to-end check may fail to identify an intermediate failure that occurred during the simulation run but was masked or overwritten by a subsequent simulation run. 
     A current method of overcoming these problems involves writing verification programs at the simulation phase of the design process that are designed to monitor, during the course of a simulation run, correctness characteristics and intermediate results. These verification programs are typically written in high level programming languages such as C or C++ Languages such as C and C++ typically have greater expressiveness than HDL languages thereby facilitating the creation of complex checking programs. A problem associated with this method, however, is that it adds further complexity to the simulation process by requiring an extra communication step between designers and simulation programmers. The efficiency and effectiveness of the simulation testing are therefore reduced. Another problem with utilizing verification programs written in languages such as C++ or C is that these programs are not amenable to execution on a hardware simulator. In general, hardware simulators must be stopped after each simulation time period and the verification programs allowed to access the executable simulation model internals to perform their checking and monitoring functions. Such stoppages usually have a dramatic negative impact on the performance of hardware simulators. 
     Based on the foregoing, it can be appreciated that a need exists for a method and system that utilize the inherent hierarchical and modular nature of HDLs to provide simulation instrumentation in the form of HDL entities for digital circuit design simulation models. Such a method and system would be useful by permitting accurate monitoring of performance characteristics of specific modules or components of an overall model in order to more efficiently and accurately identify failures and assess the logical correctness of the overall model. 
     SUMMARY OF THE INVENTION 
     It is therefore an object of the invention to provide a method and system for interactively designing and simulating complex circuits and systems, particularly digital devices, modules and systems. 
     It is another object of the invention to provide a method and system for efficiently simulating and verifying the logical correctness of complex digital circuit designs. 
     It is still another object of the present invention to provide a method and system that improve the model build and simulation processes in order to allow a designer to easily instrument and monitor a simulation model. 
     It is yet another object of the invention to provide a method and system that utilize instrumentation modules written in a hardware description language to monitor the performance of computer-generated digital circuit designs. 
     The above and other objects are achieved as is now described. A method and system are disclosed that utilize the expressiveness of hardware description languages for incrementally compiling instrumentation logic into a simulation model of a digital circuit design. According to the present invention, a simulation model that includes a design entity file of a digital circuit design is generated. Next, an instrumentation entity file is associated with the design entity file, thereby producing an instrumented design entity file. Finally, and during the process of compiling the simulation model, for the instrumented design entity file: searching for a consistent and previously compiled version of said instrumented design entity file. In response to finding a consistent and previously compiled version, loading the consistent and previously compiled version into the simulation model. In response to finding no consistent and previously compiled version, loading and compiling the instrumented design entity file. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     The novel features believed characteristic of the invention are set forth in the appended claims. The invention itself, however, as well as a preferred mode of use, further objects, and advantages thereof, will best be understood by reference to the following detailed description of an illustrative embodiment when read in conjunction with the accompanying drawings, wherein: 
     FIG. 1 illustrates a pictorial representation of a data processing system in which a preferred embodiment of the present invention may be implemented; 
     FIG. 2 depicts a representative hardware environment of the data processing system illustrated in FIG. 1; 
     FIG. 3A illustrates a simplified block diagram of a digital design entity in which a preferred embodiment of the present invention may be implemented; 
     FIG. 3B depicts a diagrammatic representation of a simulation model in which a preferred embodiment of the present invention may be advantageously utilized; 
     FIG. 3C is a flow diagram illustrative of a model build process in which a preferred embodiment of the present invention may be implemented; 
     FIG. 3D depicts a block diagram representative of data structures on which a preferred embodiment of the present invention may be utilized; 
     FIG. 4A illustrates a simplified block diagram of an instrumentation entity utilized in a preferred embodiment of the present invention; 
     FIG. 4B depicts a simplified block diagram of a simulation model instrumented in accordance with the teachings of the present invention; 
     FIG. 4C illustrates exemplary sections of HDL syntax utilized in a preferred embodiment of the present invention; 
     FIG. 4D is a flow diagram depicting a model build process in accordance with the teachings of the present invention; 
     FIG. 4E illustrates a block diagram representative of memory data structures in accordance with the teachings of the present invention; 
     FIG. 5A depicts a logic diagram of a runtime disable mechanism in accordance with a preferred embodiment of the present invention; 
     FIG. 5B illustrates a simplified block diagram of functional units utilized to execute the method and system of the present invention on a hardware simulator in accordance with the teachings of the present invention; 
     FIG. 6A depicts a simplified gate level representation of an exemplary counting instrument with a runtime disable feature and automatic clocking adjustment in accordance with the teachings of the present invention; and 
     FIG. 6B is a simplified timing diagram illustrating operation of automatic clocking adjustment of counting instrumentation in accordance with a preferred embodiment of the present invention. 
    
    
     DETAILED DESCRIPTION OF PREFERRED EMBODIMENT 
     The present invention accomplishes the goal of accurately and comprehensively monitoring the operation of a digital circuit design by allowing for designer creation of instrumentation modules in the same hardware description language (HDL) as utilized for the design. HDLs, while suited to the needs of digital designers can also be effectively utilized for a number of checking functions. By allowing a digital designer to utilize the HDL to create checking and instrumentation modules, the need to learn a language such as C or C++ is eliminated. These instrumentation modules will be utilized to monitor specified design parameters while not becoming an integral part of the design itself. Furthermore, since these instrumentation modules are written in the same HDL as utilized in the actual design, such modules are platform and simulator independent. Unlike checking done with C or C++ programs, HDL instrumentation can be compiled and run directly without loss of performance on hardware simulators. 
     With reference now to the figures and in particular with reference to FIG. 1, there is depicted a pictorial representation of a data processing system  10  with which the present invention may advantageously be utilized. As illustrated, data processing system  10  comprises a workstation  12  to which one or more nodes  13  are connected. Workstation  12  preferably comprises a high performance multiprocessor computer, such as the RISC System/6000 or AS/400 computer systems available from International Business Machines Corporation (IBM). Workstation  12  preferably includes nonvolatile and volatile internal storage for storing software applications comprising an ECAD system, which can be utilized to develop and verify a digital circuit design in accordance with the method and system of the present invention. As depicted, nodes  13  are comprised of a display device  14 , a keyboard  16 , and a mouse  20 . The ECAD software applications executed within workstation  12  preferably display a graphic user interface (GUI) within display screen  22  of display device  14  with which a digital circuit designer can interact using a keyboard  16  and mouse  20 . Thus, by entering appropriate inputs utilizing keyboard  16  and mouse  20 , the digital circuit designer is able to develop and verify a digital circuit design according to the method described further hereinbelow. 
     FIG. 2 depicts a representative hardware environment of data processing system  10  illustrated in FIG.  1 . In FIG.  1  and FIG. 2, like parts are identified by like numbers. Data processing system  10  in FIG. 2 is thus a configuration that includes all functional components of a computer and its associated hardware. Data processing system  10  includes a Central Processing Unit (“CPU”)  24 , such as a conventional microprocessor, and a number of other units interconnected via system bus  26 . CPU  24  includes a portion of data processing system  10  that controls the operation of the entire computer system, including executing the arithmetical and logical functions contained in a particular computer program. Although not depicted in FIG. 2, CPUs such as CPU  24  typically include a control unit that organizes data and program storage in a computer memory and transfers the data and other information between the various parts of the computer system. Such CPUs also generally include an arithmetic unit that executes the arithmetical and logical operations, such as addition, comparison, multiplications and so forth. Such components and units of data processing system  10  can be implemented in a system unit such as workstation  12  of FIG.  1 . 
     Data processing system  10  further includes random-access memory (RAM)  28 , read-only memory (ROM)  30 , display adapter  32  for connecting system bus  26  to display device  14 , and I/O adapter  34  for connecting peripheral devices (e.g., disk and tape drives  33 ) to system bus  26 . RAM  28  is a type of memory designed such that the location of data stored in it is independent of the content. Also, any location in RAM  28  can be accessed directly without having to work through from the beginning. ROM  30  is a type of memory that retains information permanently and in which the stored information cannot be altered by a program or normal operation of a computer. 
     Display device  14  is the visual output of data processing system  10 . Display device  14  can be a cathode-ray tube (CRT) based video display well-known in the art of computer hardware. However, with a portable or notebook-based computer, display device  14  can be replaced with a liquid crystal display (LCD) based or gas plasma-based flat-panel display. Data processing system  10  further includes user interface adapter  36  for connecting keyboard  16 , mouse  20 , speaker  38 , microphone  40 , and/or other user interface devices, such as a touch-screen device (not shown), to system bus  26 . Speaker  38  is one type of audio device that may be utilized in association with the method and system provided herein to assist diagnosticians or computer users in analyzing data processing system  10  for system failures, errors, and discrepancies. Communications adapter  42  connects data processing system  10  to a computer network. Although data processing system  10  is shown to contain only a single CPU and a single system bus, it should be understood that the present invention applies equally to computer systems that have multiple CPUs and to computer systems that have multiple buses that each perform different functions in different ways. 
     Data processing system  10  also includes an interface that resides within a machine-readable media to direct the operation of data processing system  10 . Any suitable machine-readable media may retain the interface, such as RAM  28 , ROM  30 , a magnetic disk, magnetic tape, or optical disk (the last three being located in disk and tape drives  33 ). Any suitable operating system and associated interface (e.g., Microsoft Windows) may direct CPU  24 . For example, the AIX operating system and AIX Windows windowing system can direct CPU  24 . The AIX operating system is IBM&#39;s implementation of the UNIX™ operating system. Other technologies also can be utilized in conjunction with CPU  24 , such as touch-screen technology or human voice control. 
     Those skilled in the art will appreciate that the hardware depicted in FIG. 2 may vary for specific design and simulation applications. For example, other peripheral devices such as optical disk media, audio adapters, or chip programming devices, such as PAL or EPROM programming devices well-known in the art of computer hardware and the like, may be utilized in addition to or in place of the hardware already depicted. In addition, main memory  44  is connected to system bus  26 , and includes a control program  46 . Control program  46  resides within main memory  44 , and contains instructions that, when executed on CPU  24 , carries out the operations depicted in FIG.  4 D and FIG. 4E described herein. 
     It is important to note that, while the present invention has been, and will continue to be, described in the context of a fully functional computer system, those skilled in the art will appreciate that the present invention is capable of being distributed as a program product in a variety of forms, and that the present invention applies equally regardless of the particular type of signal-bearing media utilized to actually carry out the distribution. Examples of signal-bearing media include: recordable-type media, such as floppy disks, hard disk drives, and CD ROMs, and transmission-type media such as digital and analog communication links. 
     Simulation models of digital circuit designs are comprised of at least one and usually many sub-units referred to hereinafter as design entities. FIG. 3A illustrates a block diagram representation of an exemplary design entity  300  on which the method and system of the present invention may be implemented. Design entity  300  is defined by a number of components: an entity name, entity ports, and a representation of the function performed by design entity  300 . Each entity within a given model has a unique name, not explicitly shown in FIG. 3A, that is declared in the HDL description of each entity. Furthermore, each entity typically contains a number of signal interconnections, known as ports, to signals outside the entity. These outside signals may be primary input/outputs (I/Os) of an overall design or signals connecting to other entities within an overall design. 
     Typically, ports are of one of three distinct types: input ports, output ports, and bi-directional ports. Design entity  300  of FIG. 3A is depicted as having a number of input ports  303  that convey signals into design entity  300 . Input ports  303  are connected to input signals  301 . In addition, design entity  300  is depicted as having a number of output ports  306  that convey signals out of design entity  300 . Output ports  306  are connected to a set of output signals  304 . Bi-directional ports  305  are utilized to convey signals into and out of design entity  300 . Bi-directional ports  305  are in turn connected to a set of bi-directional signals  309 . An entity, such as design entity  300 , need not contain ports of all three types, and in the degenerate case, contains no ports at all. To accomplish the connection of entity ports to external signals, a mapping technique, known as a “port map”, is utilized. A port map (not explicitly depicted in FIG.  3 A), consists of a specified correspondence between entity port names and external signals to which the entity is connected. When building a simulation model, ECAD software is utilized to connect external signals to appropriate ports of the entity according to a port map specification. 
     Finally, design entity  300  contains a body section  308  that describes one or more functions performed by design entity  300 . In the case of a digital design, body section  308  contains an interconnection of logic gates, storage elements, other devices, and instantiations of other entities. By instantiating another entity within an entity, a hierarchical description of an overall design is achieved. For example, a microprocessor may contain multiple instances of an identical functional unit. In such a circumstance, it will often be the case that the microprocessor itself will be modeled as a single entity. Within the microprocessor entity, multiple instantiations of any duplicated functional entities will be present. 
     Referring now to FIG. 3B, there is illustrated a diagrammatic representation of an exemplary simulation model  329  in which a preferred embodiment of the present invention may be advantageously utilized. Simulation model  329  consists of multiple hierarchical entities. For clarity, the ports and signals interconnecting the entities within simulation model  329  have not been shown explicitly. In any model, one and only one entity is the so called “top-level entity”. A top-level entity  320 , is that entity which encompasses all other entities within simulation model  329 . That is to say, top-level entity  320  instantiates, either directly or indirectly, all descendant entities within a design. Simulation model  329  consists of top-level entity  320  which directly instantiates two instances,  321   a  and  321   b  of an FXU entity  321  and a single instance of an FPU entity  322 . Each instantiation has an assocatiated description which contains an entity name and a unique instantiation name. For top-level entity  320 , a description  310  is illustrated as “TOP:TOP”. Description  310  includes an entity name  312 , depicted as the “TOP” preceeding the colon, and also includes an instantiation name  314 , depicted as the “TOP” following the colon. 
     It is possible for a particular entity to be instantiated multiple times such as is depicted with instantiations  321   a  and  321   b  of FXU entity  321 . Instantiations  321   a  and  321   b  are distinct instantiations of FXU entity  321  with instantiation names FXU 0  and FXU 1  respectively. Top level entity  320  is at the highest level within the hierarchy of simulation model  329 . An entity that instantiates a descendant entity will be referred to hereinafter as an ancestor of the descendant entity. Top-level entity  320  is therefore the ancestor that directly instantiates FXU entity instantiations  321   a  and  321   b . At any given level of a simulation model hierarchy, the instantiation names of all instantiations must be unique. 
     In addition to FXU entity instantiations  321   a  and  321   b , top level entity  320  directly instantiates a single instance of a FPU entity  322 , with entity name FPU and instantiation name FPU 0 . Within an entity description, it is common for the entity name to match the instantiation name when only one instance of that particular entity is placed at a given level of a simulation model hierarchy. However, this is not required as shown by entity  322  (instantiation name FPU 0 , entity name FPU). 
     Within instantiation  321   a  of FXU entity  321 , single instance entities  325   a  and  326   a  of entity A  325  and entity B  326  respectively, are directly instantiated. Similarly instantiation  321   b  of the same FXU entity contains instantiations  325   b  and  326   b  of entity A  325  and entity B  326  respectively. In a similar manner instantiation  326   a  and instantiation  326   b  each directly instantiate a single instance of entity  327   a  and  327   b  respectively, of entity C  327 . The nesting of entities within other entities can continue to an arbitrary level of complexity provided that all entities instantiated, whether singly or multiply, have unique entity names and the instantiation names at any given level of the hierarchy are unique with respect to one another. Each entity is constructed from one or more HDL files that contain the information necessary to describe the entity. 
     Associated with each entity instantiation is a so called “instantiation identifier”. The instantiation identifier for a given instantiation is a string consisting of the enclosing entity instantion names proceeding from the top level entity instantiation name. For example, the instantiation identifier of instantiation  327   a  of entity C  327  within instantiation  321   a  of FXU entity  321  is “TOP.FXU 0 .B.C”. This identifier serves to uniquely identify each instantiation with a simulation model. 
     Referring now to FIG. 3C, there is depicted a flow diagram of one possible model build process in which a preferred embodiment of the present invention may be implemented. The process begins with one or more design entity HDL source code files  340  and, potentially, one or more design entity intermediate format files  345 , hereinafter referred to as “proto files”  345 , available from a previous run of HDL compiler  342 . HDL compiler  342  processes HDL file(s)  340  beginning with the top level entity of a simulation model and proceeding in a recursive fashion through all HDL or proto file(s) describing a complete simulation model. During the process of compilation, HDL compiler  342 , for each of HDL files  340 , examines proto files  345  to determine if a previously compiled proto file is available and consistent. If such a file is available and consistent, HDL compiler  342  will not recompile that particular file, but will rather refer to the already extant proto file. If no such proto file is available or said proto file is not consistent, HDL compiler  342  will recompile the HDL file  340  in question explicitly and create a proto file  344 , for use in subsequent compilations. Such a process will be referred to hereinafter as “incremental compilation” and can greatly speed the process of creating a simulation executable model  348 . Incremental compilation will be shown in greater detail hereinbelow. Proto files  344 , once created by HDL compiler  342 , are available to serve as proto files  345  in subsequent compilations. 
     In addition to proto files  344 , HDL compiler  342  also creates two sets of data structures, design entity proto data structures  341  and design entity instance data structures  343 , in memory  44  of computer system  10 . Design entity proto data structures  341  and design entity instance data structures  343 , described hereinbelow in greater detail, serve as a memory image of the contents of a simulation executable model  348 . Data structures  341  and  343  are passed, via memory  44 , to a model build tool  346  for processing. Model build tool  346  processes data structures  341  and  343  into simulation executable model  348 . 
     Hereinafter, for clarity of exposition, it will be assumed that each entity is described by a single HDL file. Depending on convention or the particular HDL in which the current invention is practiced, this restriction may be required. However, in certain circumstances or for certain HDLs it is possible to describe an entity by utilizing more than one HDL file. Those skilled in the art will appreciate and understand the extensions necessary to practice the present invention if entities are permitted to be described by multiple HDL files. Furthermore, it will be assumed that there is a direct correspondence, for each entity, between the entity name and both of the following: the name of the HDL file representing the entity and the name of the proto file for the entity. 
     In the following description, an HDL source code file corresponding to a given entity will be referred to by an entity name followed by “.vhdl”. For example, the HDL source code file that describes top level entity  320 , will be referred to as TOP.vhdl. This labeling convention serves as a notational convenience only and should not be construed as limiting the applicability of the present invention to HDLs other than VHDL. 
     Returning to FIG. 3B, it can be seen that each entity may instantiate, either directly or indirectly, one or more other entities. For example, the FXU entity directly instantiates A entity  325  and B entity  326 . Furthermore, B entity  326  directly instantiates C entity  327 . Therefore, FXU entity  321  instantiates, directly or indirectly, A entity  325 , B entity  326  and C entity  327 . For clarity, those entities, that are directly or indirectly instantiated by another entity, will be referred to hereinafter as “descendants”. Therefore, the descendants of top level entity  320  are FXU entity  321 , FPU entity  322 , A entity  325 , B entity  326 , and C entity  327 . It can be seen that each entity has a unique set of descendants and each time an entity is instantiated, a unique instance of the entity and its descendants is created. For example in simulation model  329 , FXU entity  321  is instantiated twice, FXU:FXU 0   321   a  and FXU:FXU 1   321   b , by top level entity  320 . Each instantiation of FXU entity  321  creates a unique set of instances of the FXU, A, B, and C entities. 
     For each entity, it is possible to define what is referred to as a “bill-of-materials” or BOM. A BOM is a list of HDL files, with date and time stamps, of the entity itself and the entity&#39;s descendants. Referring again to FIG. 3C, the BOM for an entity is stored in proto file  344  for the entity created when HDL compiler  342  compiles HDL file  340  for the entity. In other words, when HDL compiler  342  compiles a particular HDL source code file among HDL files  340 , a proto file  344  is generated that contains, among other components, a BOM listing the HDL files  340  that constitute the entity and the entity&#39;s descendants, if any. The BOM also contains the date and time stamp for each of the HDL files referenced as each appeared on disk/tape  33  of computer system  10  when the HDL file was being compiled. 
     In this manner, if any of the HDL files constituting an entity or the entity&#39;s descendants is subsequently changed, proto file  344  will be flagged as inconsistent and HDL compiler  342  will recompile HDL file  340  on a subsequent recompilation as will be shown below. For example, going back to FIG. 3B, the HDL files referenced by the BOM of FXU entity  321  are FXU.vhdl, A.vhdl, B.vhdl and C.vhdl, each with appropriate date and time stamps. The files referenced by the BOM of top level entity  320  are TOP.vhdl, FXU.vhdl, A.vhdl, B.vhdl, C.vhdl, and FPU.vhdl with appropriate date and time stamps. 
     Returning to FIG. 3C, HDL compiler  342  creates an image of the structure of a simulation model in main memory  44  of computer system  10 . This memory image is comprised of two major types of components: “proto” data structures  341  and “instance” data structures  343 . A proto is a data structure that, for each entity in the model, contains information about the ports of the entity, the body contents of the entity, and a list of references to other entities directly instantiated by the entity (in what follows, the term “proto” will be utilized to refer to the in-memory data structure described above and the term “proto file” will be utilized to describe intermediate format file(s)  344 ). Proto files  344 , produced by HDL compiler  342 , are on-disk representations of the in-memory proto data structure. 
     An instance data structure is a data structure that, for each instance of an entity within a model, contains the instance name for the instance, the name of the entity the instance refers to, and finally the port map information necessary to interconnect the entity with external signals. During compilation, each entity will have only one proto data structure, while, in the case of multiple instantiations of an entity, each entity may have one or more instance data structures. 
     In order to incrementally compile a model efficiently, HDL compiler  342  follows a recursive method of compilation in which successive entities of the model are considered and loaded from proto files  345  if such files are available and are consistent with the HDL source files constituting those entities and their descendants. For each entity that cannot be loaded from existing proto files  345 , HDL compiler  342  recursively examines the descendant entities of the entity, loading those descendant entities available from proto file(s)  345  and creating, as needed, proto files  344  for those descendant entities that are inconsistent with proto files  345 . Psuedocode for the main control loop of HDL compiler  342  is shown below (the line numbers to the right of the psuedocode are not a part of the psuedocode, but merely serve as a notational convenience). 
     
       
         
           
               
               
             
               
                   
               
             
            
               
                 process_HDL_file(file) 
                 5 
               
               
                 { 
                 10 
               
            
           
           
               
               
               
            
               
                   
                 if (NOT proto_loaded(file)) { 
                 15 
               
               
                   
                 if (exists_proto_file(file) AND check_bom(file)) { 
                 20 
               
            
           
           
               
               
               
            
               
                   
                 load_proto(file); 
                 25 
               
            
           
           
               
               
               
            
               
                   
                 } else { 
                 30 
               
            
           
           
               
               
               
            
               
                   
                 parse_HDL_file(file) 
                 35 
               
               
                   
                 for (all instances in file) { 
                 40 
               
            
           
           
               
               
               
            
               
                   
                 process_HDL_file(instance); 
                 45 
               
            
           
           
               
               
               
            
               
                   
                 } 
                 50 
               
               
                   
                 create_proto(file); 
                 55 
               
               
                   
                 write_proto_file(file); 
                 60 
               
            
           
           
               
               
               
            
               
                   
                 } 
                 65 
               
            
           
           
               
               
               
            
               
                   
                 } 
                 70 
               
               
                   
                 create instance(file): 
                 75 
               
            
           
           
               
               
            
               
                 } 
                 80 
               
               
                   
               
            
           
         
       
     
     When compiler  342  is initially invoked, no proto data structures  341  or instance data structures  343  are present in memory  44  of computer system  10 . The main control loop, routine process_HDL_file( ) (line 5), is invoked and passed the name of the top level entity by means of parameter “file”. The algorithm first determines if a proto data structure for the current entity is present in memory  44  by means of routine proto_loaded( ) (line 15). Note that the proto data structure for the top level entity will never be present in memory because the process starts with no proto data structures loaded into memory  44 . If a matching proto data structure is present in memory  44 , instance data structures for the current entity and the current entity&#39;s descendants, if any, are created as necessary in memory  44  by routine create-instance( ) (line 75). 
     However, if a matching proto data structure is not present in memory  44 , control passes to line 20 where routine exists_proto_file( ) examines proto files  345  to determine if a proto file exists for the entity. If and only if a matching proto file exists, routine check_bom( ) is called to determine if proto file  345  is consistent. In order to determine if the proto file is consistent, the BOM for the proto file is examined. Routine check_bom( ) examines each HDL source code file listed in the BOM to determine if the date or time stamps for the HDL source code file have changed or if the HDL source code file has been deleted. If either condition occurs for any file in the BOM, the proto file is inconsistent and routine check_bom( ) fails. However, if check_bom( ) is successful, control is passed to line 25 where routine load_proto( ) loads the proto file and any descendant proto files into memory  44  creating proto data structures  341  for the current entity and the current entity&#39;s descendants, if any. The construction of process_HDL_file( ) ensures that once a proto file has been deemed consistent, all of its descendant proto files, if any, are also consistent. 
     If, however, the proto file is either non-existent or is not consistent, control passes to line 35 where routine parse_HDL_file( ) loads the HDL source code file for the current entity. Routine parse HDL_file( ) (line 35) examines the HDL source code file for syntactic correctness and determines which descendant entities, if any, are instantiated by the current entity. Lines 40, 45, and 50 constitute a loop in which the routine process_HDL_file( ) is recursively called to process the descendent entities that are called by the current entity. This process repeats recursively traversing all the descendants of the current entity in a depth first fashion creating proto data structures  341  and proto data files  344  of the descendants of the current entity. Once the descendant entities are processed, control passes to line 55 where a new proto data structure is created for the current entity in memory  44  by routine create_proto( ). Control then passes to line 60 where a new proto file  344 , including an associated BOM, is written to disk  33  by routine write_proto_file( ). Finally, control passes to line 75 where routine create_instance( ) creates instance data structures  343  for the current entity and any descendant entities as necessary. In this manner, process-HDL-file( ) (line 5) recursively processes the entire simulation model creating an in-memory image of the model consisting of proto data structures  341  and instance data structures  343 . 
     With reference now to FIG. 3D there is depicted a block diagram representative of compiled data structures on which a preferred embodiment of the present invention may be implemented. Memory  44  contains proto data structures  361 , one for each of the entities referred to in simulation model  329 . In addition, instantiations in simulation model  329  are represented by instance data structures  362 . Instance data structures  362  are connected by means of pointers indicating the hierarchical nature of the instantiations of the entities within simulation model  329 . Model build tool  346  processes the contents of memory  44  in memory data structures in order to produce simulation executable model  348 . 
     In order to instrument simulation models, the present invention makes use of entities known as “instrumentation entities”. An instrumentation entity is an entity with specific characteristics, as described below. An instrumentation entity is written utilizing the same HDL utilized to describe the entities in the design. In contrast to instrumentation entities, the entities constituting a design will hereinafter be referred to as “design entities”. Instrumentation entities, as with design entities are described by one or more HDL source code files and consist of a number of signal ports, a body section, and an entity name. In what follows, it will be assumed that an instrumentation entity is described by a single HDL file. Those skilled in the art will appreciate and understand extensions necessary to practice the current invention for an instrumentation entity that is described by multiple HDL files. 
     Each instrumentation entity is associated with a specific design entity referred to hereinafter as the “target entity”. The mechanism of the current invention provides a means of creating and connecting an instance of an instrumentation entity to each instance of the target entity within a simulation model. 
     With reference now to FIG. 4A there is illustrated a representation of an instrumentation entity  409 . As with a design entity, instrumentation entity  409  has a number of input ports  400  which are connected, as described below, to signals  401  within the target entity which is not depicted in FIG. 4A. A body section  402  of instrumentation entity  409 , contains logic necessary to detect occurrences of certain “events” on signals  401  of the target entity. A preferred embodiment of the present invention provides for monitoring three distinct types of events: “count” events, “fail” events, and “harvest” events, each described below in turn. Body section  402  contains internal logic which instrumentation entity  409  utilizes to detect occurrences of these events. A set of multi-bit output ports  403 ,  404 , and  405  are connected to external instrumentation logic not depicted in FIG. 4A by means of external signals  406 ,  407 , and  408 . Output ports  403 ,  404 , and  405  provide the connection from the internal logic in body section  402  to the external instrumentation logic which is utilized to indicate the occurrence of count, failure and harvest events. 
     The method and system of the present invention provides for the monitoring of three distinct types of events within a simulation model. The first of these events is a failure event. A failure event is a sequence of signal values that indicate a failure in the correct operation of the simulation model. Each instrumentation entity can monitor the target entity for any desired number of failure events. Each failure occurrence is assigned to a particular signal bit on output port  403 . Input ports  400  are connected to body section  402  containing logic necessary to detect the occurrence of the desired failure events. The logic of body section  402  produces an active high pulse on the correct bit of signal  403  when a failure event is detected. This error indication is conveyed by means of external signal  406  to external instrumentation logic, depicted in FIG. 4B as external instrumentation logic block  420 , which flags the occurrence of the failure event. 
     In contrast to a failure event, a count event is a sequence of signal values that indicate the occurrence of an event within a simulation model for which it would be advantageous to maintain a count of the number of occurrences. Count events are utilized to monitor the frequency of occurrence of specific sequences within a simulation model. Each instrumentation entity can monitor the target entity for any desired number of count events. Each count event is assigned to a particular signal bit on output port  405 . Input ports  400  are connected to logic block  402  containing the logic necessary to detect the occurrence of the desired count events. The logic of block  402  produces an active high pulse on the correct bit of signal  405  when a count event is detected. This count indication is conveyed by means of external signal  408  to instrumentation logic which contains counters utilized to record the number of occurrences of each count event. 
     Finally, a harvest event is a sequence of signal values that indicate the occurrence of a specific circumstance which would be advantageous to be able to reproduce. When a harvest event occurs, a register is loaded to indicate at what point within a simulation run the event occurred and a flag is set to indicate the occurrence of the specific circumstance. This allows the details of the simulation run to be saved in order to be able to recreate the specific circumstance monitored by the harvest event. Input ports  400  are connected to logic block  402  containing the logic necessary to detect the harvest events. 
     Each instrumentation entity can detect any desired number of harvest events. Each harvest event is assigned to a particular signal bit on output port  404 . The logic of block  402  produces an active high pulse on the correct bit of signal  404  when a harvest event is detected. This harvest indication is conveyed by means of external signal  407  to external instrumentation logic which contains a register and flag for each harvest event. The register is utilized to record at which point in the simulation run the event occurred and the flag is utilized to indicate the occurrence of the event. One skilled in the art will recognize that it is possible to define additional types of events beyond those described above. 
     Instrumentation entities need not monitor for all three types of events. An instrumentation entity may monitor any non-empty subset of the three event types. Any design entity in a simulation model may be a target entity. Also, it is possible for more than one instrumentation entity to be associated with a particular design entity. 
     With reference now to FIG. 4B, wherein is depicted a representation of simulation model  329  instrumented in accordance with the teachings of the present invention. As can be seen in FIG. 4B, an instance  410  and an instance  411  of instrumentation entity FXUCHK are depicted monitoring instances  321   a  and  321   b  of an FXU entity. For each instantiation of FXU entity,  321   a  and  321   b , an instantiation,  410  and  411  respectively, of FXUCHK is automatically generated by the mechanism of the present invention. In a similar fashion, instrumentation entity FPUCHK  412 , is instantiated to monitor FPU entity  322 . It should be noted that a significant advantage of the present invention is the automatic instantiation of instrumentation entities for each instance of a target entity. 
     Each instrumentation entity can monitor any signal within its associated target entity. In the example of FIG. 4B, entity FXUCHK is depicted as monitoring a signals Q  372 , a signal R  376 , and a signal S  374  within each of instances  321   a  and  321   b  of the FXU entity. Signal Q  372 , is a signal within the instances  325   a  and  325   b  of descendant entity A. Likewise, signal S  374  is a signal within descendant entity C which is within descendant entity B. Finally, signal R  376  occurs directly within FXU entity  321 . An instrumentation entity may monitor any signal within a target entity or the target entity&#39;s descendent entities. However, signals outside the target entity cannot be monitored. 
     Each instrumentation entity is connected by means of fail, count, and harvest signals to an instrumentation logic block  420 . Instrumentation logic block  420  is generated automatically by the mechanism of the present invention and contains logic for recording occurrences of each of the three event types. For the count events monitored in simulation model  329 , a set of counters  421  are utilized to count the number of occurrences of each count event. In a similar manner, a set of flags  424  is utilized to record the occurrence of failure events. Finally, a set of counters  422  and flags  423  are combined and utilized to record the point at which a harvest event occurs and the fact that a harvest event occurred, respectively. In one possible embodiment of the present invention, a cycle number is captured and stored utilizing counters  422  and flags  423  to record a harvest event. The logic structures of instrumentation logic block  420  are created by the mechanism of the present invention without direct intervention by the user. 
     In order to allow the method and system of the present invention to instantiate and connect instances of instrumentation entities, instrumentation entity HDL source code files include a specialized comment section, hereinafter referred to as “instrumentation entity description”, in a particular form that indicate the target entity for the instrumentation entity, the signals within the target entity to be monitored, and information for the different types of events monitored. It will be appreciated by those skilled in the art that it would be possible to directly extend the syntax of an HDL to support the encoding of this information without resorting to the use of comments as is described here. 
     With reference now to FIG. 4C there is illustrated an exemplary HDL file  440  that describes instrumentation entity FXUCHK depicted in FIG.  4 B. HDL file  440  utilizes the syntax of the VHDL hardware description language. In the VHDL language, lines beginning with two dashes, “--”, are recognized by a compiler as being comment lines. The method and system of the present invention utilize comments of a non-conventional form to indicate information about an instrumentation entity. It will be appreciated by those skilled in the art that the exemplary syntax utilized in FIG. 4C is but one of many possible formats. FIG. 4C depicts one embodiment of the present invention in which comment lines that are utilized by the method and system of the present invention, begin with two exclamation points in order to distinguish these comments from conventional comments in instrumentation HDL file  440 . 
     Within HDL file  440 , the I/O ports of a FXUCHK entity are declared in entity declaration  450 . Within entity declaration  450 , three input ports, S_IN , Q_IN , and R_IN, respectively, are declared. Input ports, S_IN , Q_IN , and R_IN, will be attached to signal S,  374 , signal Q,  372 , and signal R,  376  respectively as described below. Input port, CLOCK, is also declared and will be connected to a signal, CLOCK, within the FXU entity and is as described below. In addition, three output ports: fails (0 to 1), counts (0 to 2), and harvests (0 to 1), are declared. These output ports provide failure, count, and harvest signals for two failure events, three count events, and two harvest events. In a preferred embodiment of the present invention, the names of the output ports are fixed by convention in order to provide an efficient means for automatically connecting these signals to instrumentation logic block  420 . 
     A set of instrumentation entity descriptors  451  are utilized to provide the mechanism of the present invention information about the instrumentation entity. As seen in FIG. 4C, descriptor comments  451  may be categorized in a number of distinct sections: prologue and entity name declaration  452 , an input port map  453 , a set of failure message declarations  454 , a set of counter declarations  455 , a set of harvest declarations  456 , and an epilogue  457 . 
     The prologue and entity name  452  serve to indicate the name of the particular target entity that the instrumentation entity will monitor. Prolog and entity name declaration  452  also serves as an indication that the instrumentation entity description has begun. Specifically, the comment “--!! Begin” within prologue and entity name  452 , indicates that the description of an instrumentation entity has begun. The comment “--!! Design Entity: FXU” identifies the target entity of the instrumentation entity which in HDL file  440  of FIG. 4C is design entity FXU. In a preferred embodiment of the present invention, this declaration serves to bind the instrumentation entity to the target entity. 
     Input port map  453  serves as a connection between the input ports of an instrumentation entity and the signals to be monitored within the target entity. The comments begin with comment “--!! Inputs” and end with comment “--!! End Inputs”. Between these comments, comments of the form “--!! inst_ent_port_name =&gt; trgt_ent_signal_name” are utilized, one for each input port of the instrumentation entity, to indicate connections between the instrumentation entity ports and the target entity signals. The inst_ent_port_name is the name of the instrumentation entity port to be connected to the target entity signal. The trgt_ent_signal name is the name of the signal within the target entity that will be connected to the instrumentation entity port. 
     It may be the case that a signal to be monitored lies within a descendant of a target entity. This is the case for signal S  374  which is embedded within entity C which is a descendant of entity B  326  and target FXU entity  321 . Input port map  453  an identification string for signal S  374  which includes the instance names of the entities within the target entity each separated by periods (“.”). This identification string is pre-pended to the signal name. The signal mapping comment within input port map  453  for signal S  374  is therefore as follows: 
     
       
         --!! S_IN =&gt; B.C.S.; 
       
     
     This syntax allows an instrumentation entity to connect to any signal within the target entity or the target entity&#39;s descendant entities. Signals, such as R  376 , appearing on the top level of the target design entity have no pre-pended entity names: 
     
       
         --!! R_IN =&gt; R; 
       
     
     One, and only one, signal mapping comment must be provided for each input port of the instrumentation entity. 
     Failure message declarations  454  begin with a comment of the form “--!! Fail Outputs;”, and end with a comment of the form “--!! End Fail Outputs;”. Each failure event output is associated with a failure message. This message may be output by the simulation run-time environment upon detecting a failure event. Each failure event signal may be declared by a comment of the form “--!! n: “failure message”;” where n is an integer denoting which failure event the message is to be associated with and “failure message” is the message to be associated with the particular failure event. One, and only one failure message declaration comment must be provided for each failure event monitored by the instrumentation entity. 
     Counter declaration comments  455  begin with a comment of the form “--!! Count Outputs;” , and end with a comment of the form “--!! End Count Outputs;”. Each count event output is associated with a unique variable name. This name is associated with a counter in counter logic  421 . The variable name provides a means to identify and reference the particular counter associated with a particular count event. A comment of the form “--!! n : &lt;varname&gt; qualifying_signal [+/−];” is associated with each counter event output. Within this convention, n is an integer denoting which counter event in the instrumentation module is to be associated with a variable name “varname” and qualifying_signal is the name of a signal within a target design entity utilized to determine when to sample the count event pulse as will be further described hereinbelow. The parameter “qualifying_signal” is followed by “+/−” to determine whether the qualifying signal will be a high active qualifying signal or a low active qualifying signal. 
     Harvest declarations  456  begin with a prologue comment of the form “--!! Harvest Outputs;” and end with a comment of the form “--!! End Harvest Outputs;”. Each harvest event output is associated with a message that may be output by the simulation runtime environment when a harvest event has occurred during a simulation run. Each harvest event signal is declared in the form “--!! n: “harvest message”;” where n is an integer denoting which harvest event the message is to be associated with and “harvest message” is the message to be associated with the particular harvest event. One, and only one, harvest message declaration comment must be provided for each harvest event monitored by the instrumentation entity. 
     Harvest messages, fail messages, and counter variable names for a simulation model are included in a simulation executable model. In this manner, each simulation model includes the information for each event monitored. 
     It is advantageous to ensure the uniqueness of these messages and variable names in the event that multiple instances of the same instrumentation entity occur within a simulation model. To this end, the instance identifier of a target entity is pre-pended to each harvest and failure message and each variable name of all instrumentation entities. For example, the first failure message of instance  410  of the FXUCHK entity monitoring instance  321   a  (the FXU:FXU 0  instantiation) is “FU 0 : Fail message for failure event  0 ”. The instance identifier serves to indicate which particular instance of the FXUCHK entity detected a given failure. In a similar manner, the harvest messages and the variable names for each instrumentation entity instantiation are altered. 
     Finally, epilogue comment  457  consists of a single comment of the form “--!! End;”, indicating the end of descriptor comments  451 . The remainder of instrumentation entity HDL file  440  that follows the I/O declarations described above, is an entity body section  458 . In entity body section  458 , conventional HDL syntax is utilized to define internal instrumentation logic necessary to detect the various events on the input port signals and convey these events to the output port signals. 
     In addition to descriptor comments  451 , that are located in the HDL source code file for an instrumentation entity, an additional comment line is required in the target entity HDL file. A comment of the form “--!! Instrumentation: name.vhdl”, where name.vhdl is the name of the instrumentation entity HDL file, is added to the target entity HDL source code file. This comment provides a linkage between the target entity and the instrumentation entity that monitors the target entity. It is possible to have more than one such comment in a target entity when more than one instrumentation entity is associated with the target entity. These HDL file comments will hereinafter be referred to as “instrumentation entity instantiations”. 
     With reference now to FIG. 4D wherein is depicted a model build process in accordance with the teachings of the present invention. In this model build process, instrumentation load tool  464  is utilized to alter the in-memory proto and instance data structures of a simulation model thereby adding instrumentation entities to the simulation model. Instrumentation load tool  464 , utilizes descriptor comments  451 , in instrumentation HDL files  461 , to create instance data structures for the instrumentation entities within a simulation model. 
     The revised model build process of FIG. 4D begins with design entity HDL files  340  and, potentially, one or more design entity proto files  345 , available from a previous run of HDL compiler  462 , instrumentation entity HDL files  460 , and, potentially, one or more instrumentation entity proto files  461 , available from a previous run of HDL compiler  462 . HDL compiler  462 , processes design entity HDL files  340 , and the instrumentation entity HDL files,  460 , following an augmentation of algorithm process_HDL_file( ) that provides for efficient incremental compilation of the design and instrumentation entities comprising a simulation model. HDL compiler  462  loads proto data structures from design entity proto files  345  and instrumentation entity protos files  460  where such proto files are available and consistent. If such proto files are not available or are not consistent, HDL compiler  462  compiles, as needed, design entity HDL files  340  and instrumentation entity HDL files  460  in order to produce design entity proto files  344  and instrumentation entity proto files  468 . (design entity proto files  344  and instrumentation entity proto files  468  are available to serve as design entity proto files  345  and instrumentation entity proto files  460  respectively for a subsequent run of HDL compiler  462 ). 
     In addition, HDL compiler  462  creates, as necessary, in-memory design proto data structures  463  and design instance data structures  465  for the design entities of a simulation model. HDL compiler  462  also creates in-memory instrumentation proto data structures  466  for the instrumentation entities of a simulation model. 
     In order to minimize the amount of alterations necessary to allow HDL compiler  462  to perform as depicted in FIG. 4D, HDL compiler  462  neither reads nor processes descriptor comments  451 . However, HDL compiler  462  does recognize instrumentation entity instantiation comments within target entity HDL files. As such, HDL compiler  462  cannot create instance data structures for instrumentation entities, depicted in FIG. 4D as instrumentation entity data structures  467 . The creation of instance data structures requires interconnection information contained within descriptor comments  451  not processed by HDL compiler  462 . HDL compiler  462  does, however, create instrumentation proto data structures  466 . 
     The in-memory design proto data structures  463 , design instance data structures  465 , and instrumentation entity proto data structures  466  are processed by instrumentation load tool  464 . Instrumentation load tool  464  examines design entity proto data structures  463  and design entity instance data structures  465  to determine those design entities that are target entities. In a preferred embodiment of the present invention, this examination is accomplished by utilizing a particular comment format as previously described. 
     Any target entity that is loaded from design entity proto files  345  contains an instantiation for any instrumentation entities associated with the target entity. Therefore, instrumentation load tool  464  merely creates an instance data structure  467  for any such instrumentation entities and passes, unaltered, the design proto data structure  463  to instrumented design proto data structure  463   a  and design instance data structure  465  to instrumented design instance data structure  465   a.    
     If however, a target entity is loaded from design entity HDL files  340 , rather than from design entity proto files  345 , instrumentation load tool  464  must alter the design proto data structure  463  and design instance data structure  465  to instantiate the instrumentation entities for the current design entity thereby producing instrumented design proto data structure  463   a  and instrumented design instance data structure  465   a . In addition, instrumentation load tool  464  creates an instrumentation instance data structure  467  for each instrumentation entity associated with the current design entity. 
     Those design entity proto data structures  463 , altered by instrumentation load tool  464  are saved to disk  33  of computer system  10  as design entity proto files  344 . Design entity proto files  344 , which may include references to instrumentation entities, are directly loaded by a subsequent compilation of a simulation model thus saving processing by instrumentation load tool  464  on subsequent recompilations unless an alteration is made to a design entity or an associated instrumentation entity. 
     In order for HDL compiler  462  to determine if alterations were made to either a target design entity or the target design entity&#39;s associated instrumentation entities, the BOM of a target design entity is expanded to include the HDL files constituting the instrumentation entities. In this manner, HDL compiler  462  can determine, by inspection of the BOM for a given design entity, whether to recompile the design entity and the design entity&#39;s associated instrumentation entities or load these structures from proto files  345  and  461 . 
     Finally, instrumentation load tool  464  creates a unique proto and instance data structure for instrumentation logic block  420  and connects the fail, harvest, and count event signals from each instrumentation entity instantiation to instrumentation logic block  420 . Model build tool  446  processes in-memory proto and instance data structures  463   a ,  465   a ,  467 ,  466  to produce instrumented simulation executable model  480   
     In HDL compiler  462 , algorithm process_HDL_file( ) is augmented to allow for the incremental compilation of design and instrumentation entities. A pseudocode implementation of a main control loop of HDL compiler  462  is shown below: 
     
       
         
           
               
               
             
               
                   
               
             
            
               
                 process_HDL_file2(file, design_flag) 
                 5 
               
               
                 { 
                 10 
               
            
           
           
               
               
               
            
               
                   
                 if (NOT proto_loaded(file)) { 
                 15 
               
            
           
           
               
               
               
            
               
                   
                 if (exists_proto_file(file) AND check_bom(file)) { 
                 20 
               
            
           
           
               
               
               
            
               
                   
                 load_proto(file); 
                 25 
               
            
           
           
               
               
               
            
               
                   
                 } else { 
                 30 
               
            
           
           
               
               
               
            
               
                   
                 parse_HDL_file(file) 
                 35 
               
               
                   
                 for (all instances in file) { 
                 40 
               
            
           
           
               
               
               
            
               
                   
                 process_HDL_file2(instance, design_flag); 
                 45 
               
            
           
           
               
               
               
            
               
                   
                 } 
                 50 
               
               
                   
                 if (design_flag = TRUE) { 
                 55 
               
            
           
           
               
               
               
            
               
                   
                 for (all instrumentation instances in file) { 
                 60 
               
            
           
           
               
               
               
            
               
                   
                 process_HDL_file2(instance, FALSE); 
                 65 
               
            
           
           
               
               
               
            
               
                   
                 } 
                 70 
               
            
           
           
               
               
               
            
               
                   
                 } 
                 75 
               
               
                   
                 create_proto(file); 
                 80 
               
               
                   
                 write_proto_file(file); 
                 90 
               
            
           
           
               
               
               
            
               
                   
                 } 
                 95 
               
            
           
           
               
               
            
               
                   
                 } 
               
            
           
           
               
            
               
                 100 
               
            
           
           
               
               
            
               
                   
                 if (design_flag = TRUE) { 
               
            
           
           
               
            
               
                 105 
               
            
           
           
               
               
            
               
                   
                 create_instance(file); 
               
            
           
           
               
            
               
                 110 
               
            
           
           
               
               
            
               
                   
                 } 
               
            
           
           
               
            
               
                 115 
               
               
                 } 
               
               
                 120 
               
               
                   
               
            
           
         
       
     
     Algorithm process_HDL_file 2 ( ) is an augmentation to process_HDL_file( ) of HDL compiler  342  in order to support the creation of instrumented simulation models. The algorithm is invoked with the name of the top level design entity passed through parameter file and a flag indicating whether the entity being processed is a design entity or an instrumentation entity passed through parameter design_flag (design_flag = TRUE for design entities and FALSE for instrumentation entities). Algorithm process_HDL_file 2 ( ) (line 5) first checks, by means of routine proto_loaded( ) (line 15), if the proto for the current entity is already present in memory  44 . If so, processing passes to line 105. Otherwise, control is passed to line 20 and 25 where disk  33  of computer system  10  is examined to determine if proto files for the entity and its descendants (including instrumentation entities, if any) exist and are consistent. If so, the appropriate proto files are loaded from disk  10  by routine load_proto( ) (line 25) creating proto data structures, as necessary, in memory  44  for the current entity and the current entity&#39;s descendants including instrumentation entities. 
     If the proto file is unavailable or inconsistent, control passes to line 35 where the current entity HDL file is parsed. For any entities instantiated within the current entity, lines 40 to 55 recursively call process_HDL_file 2 ( ) (line 5) in order to process these descendants of the current entity. Control then passes to line 55 where the design flag parameter is examined to determine if the current entity being processed is a design entity or an instrumentation entity. If the current entity is an instrumentation entity, control passes to line 80. Otherwise, the current entity is a design entity and lines 60 to 70 recursively call process_HDL_file 2 ( ) (line 5) to process any instrumentation entities instantiated by means of instrumentation instantiation comments. It should be noted that algorithm process_HDL_file 2 ( ) (line 5) does not allow for instrumentation entities to monitor instrumentation entities. Any instrumentation entity instantiation comments within an instrumentation entity are ignored. Control then passes to line 80 where proto data structures are created in memory  44  as needed for the current entity and any instrumentation entities. Control then passes to line 90 where the newly created proto data structures are written, as needed to disk  33  of computer system  10 . 
     Control finally passes to line 105 and 110 where, if the current entity is a design entity, instance data structures are created as needed for the current entity and the current entity&#39;s descendants. If the current entity is an instrumentation entity, routine create_instance( ) (line 110) is not called. Instrumentation load tool  464  is utilized to create the in-memory instance data structures for instrumentation entities. 
     It will be apparent to those skilled in the art that HDL compiler  462  provides for an efficient incremental compilation of design and instrumentation entities. It should also be noted that the above description is but one of many possible means for accomplishing an incremental compilation of instrumentation entities. In particular, although many other options also exist, much, if not all, of the functionality of instrumentation load tool  464  can be merged into HDL compiler  462 . 
     With reference now to FIG. 4E wherein is shown a depiction of memory  44  at the completion of compilation of simulation model  329  with instrumentation entities FXUCHK and FPUCHK. Memory  44  contains proto data structures  481 , one for each of the design and instrumentation entities referred to in simulation model  329 . In addition, design and instrumentation instances in simulation model  329  are represented by instance data structures  482 . The instance data structures are connected by means of pointers indicating the hierarchical nature of the instantiations of the design and instrumentation entities within simulation model  329 . 
     With reference now to FIG. 5A, wherein is depicted failure flags  424  of instrumentation logic block  420  in greater detail. Failure flags  424  consist of registers  500   a - 500   n  utilized to accept and store an indication of the occurrence of a failure event. In what follows, the operation of a single failure flag for a particular failure event  502  will be discussed. The operation of all failure flags is similar. 
     Register  500   a  holds a value that represents whether a failure event  502  has occurred or not. Register  500   a  is initially set to a value of ‘0’ by the simulation run-time environment at the beginning of a simulation run. When failure event  502 , if enabled at register  507   a , occurs, register  500   a  is set to a value of a logical, thereby indicating the occurrence of a failure event. Register  500   a  is driven by logical OR gate  501 . Logical OR gate  501  performs a logical OR of the output of register  500   a  and a qualified failure signal  503  to create the next cycle value for register  500   a . In this manner, once register  500   a  is set to a logical ‘1’ by the occurrence of an enabled failure event, register  500   a  maintains the value of a logical ‘1’ until reset by the simulation runtime environment. Likewise, register  500   a  maintains a value of ‘0’ from the beginning of the simulation run until the occurrence of the failure event, if enabled. 
     Qualified failure signal  503  is driven by logical AND gate  505 . Logical AND gate  505  produces, on qualified failure signal  503 , the logical AND of failure signal  506  and the logical NOT of register  507   a . Register  507   a  serves as an enabling control for qualified failure signal  503 . If register  507   a  contains a value of ‘0’, logical AND gate  505  will pass failure event signal  506  unaltered to qualified failure signal  503 . In this manner, the monitoring of the failure event is enabled. Registers  507   a - 507   n  are set, by default, to a value of ‘0’. However, if register  507   a  contains a value of a logical ‘2’, qualified failure signal  503  will remain at a value of ‘0’ irrespective of the value of failure event signal  506 , thereby disabling the monitoring of failure event  502 . In this manner, register  508 , consisting of registers  507   a - 507   n , can mask the occurrence of any subset of failure events in the overall simulation model from registers  500   a - 500   n.    
     To efficiently implement the ability to selectively disable the monitoring of failure events, the simulation run-time environment includes a function that allows a user to disable monitoring of a specific failure event for a given instrumentation entity. This function will automatically set the appropriate registers among registers  507   a - 507   n  within register  508  to disable the monitoring of a particular failure event for every instance of the instrumentation entity within the overall simulation model. Instrumentation load tool  464  and model build tool  446  encode sufficient information within instrumented simulation executable model  480  to determine which failure bits within register  508  correspond to which instrumentation entities. 
     The ability to selectively disable monitoring of failure events is of particular use in large batch-simulation environments. Typically, in such an environment, a large number of general purpose computers, running software or hardware simulators, are dedicated to automatically running a large number of simulation runs. If a simulation model with a faulty instrumentation entity that incorrectly indicates failure events is run in such an environment, a large number of erroneous failures will be generated causing lost time. By selectively disabling failure events within instrumentation entities, the present invention allows simulation to continue while only disabling erroneous failure signals rather than having to disable all failure monitoring. This option is particularly useful when the process of correcting a faulty instrumentation entity and creating a new simulation model is substantially time consuming. The present invention also provides similar enabling and disabling structures for the harvest and count events within a model. 
     Logical OR gate  512  is utilized to produce a signal,  511 , that indicates whether any failure event within the model has occurred. This signal is utilized to allow hardware simulators to efficiently simulate simulation models that have been instrumented according to the teachings of the present invention. 
     With reference now to FIG. 5B there is illustrated in greater detail, features of the present invention utilized to support efficient execution of an instrumented simulation model on a hardware simulator. It should be noted that for most hardware simulators, the operation of polling a facility within a simulation model during a simulation run is often a time consuming operation. In fact, if facilities must be polled every cycle, it is often the case that as much, if not considerably more, time is spent polling a simulation model for results rather than running the actual simulation. As such, it is advantageous when using a hardware simulator to avoid polling facilities within the model during a simulation run. In addition, many hardware simulators provide a facility that instructs the hardware simulator to run a simulation without interruption until a specific signal within the simulation model attains a specific value. This facility usually results in the highest performance for a simulation run on a hardware simulator. 
     In order to execute simulation model  520  on a hardware simulator, a termination signal  513 , is typically utilized as a means to avoid having to poll the model after each cycle. Typically, a hardware simulator will cycle simulation model  520  until signal  513  is asserted to a logical ‘1’. The assertion of termination signal  513  to a logical ‘1’ indicates that a simulation run has finished. Without termination signal  513 , it would be necessary to directly poll facilities within simulation model  520  to determine when a simulation run is completed. 
     To efficiently locate and diagnose problems in simulation model  520 , it is advantageous to allow a simulation run to be stopped immediately whenever a failure event occurs during simulation of simulation model  520  (harvest events and count events are typically only polled at the end of a simulation run). This allows a user to easily locate the failure event within the simulation run, thereby facilitating debugging of the failure. In order to allow simulation models that have been instrumented according to the teachings of the present invention to efficiently execute on a hardware simulator, a comment of the form “--!! Model Done: signalname” is placed within the HDL source code file for the top level entity of the simulation model where signalname is the name of termination signal  513  within the simulation model. This comment is only utilized if present in the HDL file for the top-level entity. If such a comment is present in the HDL source code file for the top level entity, a logical OR gate  515  will automatically be included within the simulation model. Logical OR gate  515  produces the logical OR of signals  511  and  513  on signal  516 . Signal  516  is therefore asserted to a logical ‘1’ whenever the simulation run has completed (signal  513  high) or a failure event has occurred (signal  511  high). Consequently, by executing simulation model  520  in a hardware simulator until signal  516  is asserted to a value of a logical ‘1’, the instrumentation for simulation model  520  can be combined and utilized along with existing simulation termination techniques in a seamless manner. In the alternative, if the comment indicating the name of termination signal  513  is not present, logical OR gate  515  is not included in the model and signal  511  is directly connected to signal  516 . The name of signal  516  is fixed to a particular name by convention. 
     In many simulators, the passage of time within the simulated model is modeled on a cycle-to-cycle basis. That is to say, time is considered to pass in units known as cycles. A cycle is delineated by the occurrence of a clock signal within a simulation model that regulates the updating of storage elements within the design. These simulators are commonly known as “cycle simulators”. A cycle simulator models a digital design by repeatedly propagating the values contained within storage elements through interconnecting logic that lies between storage elements without specific regard for the physical timing of this propagation, to produce next cycle values within the storage elements. In such simulators, a primitive storage element, hereinafter referred to as a “simulator latch”, is utilized to model the storage elements within a digital design. One simulator cycle therefore consists of propagating the current values of the simulator latches through the interconnecting logic between storage elements and updating the simulator latches with the next cycle value. 
     In many circumstances, however, it is not possible to utilize a single simulator latch to directly model the storage elements within a design. Many common storage elements utilized within digital designs often require more than one simulator latch. For example, so called master-slave flip-flops are generally modeled utilizing two simulator latches to accurately simulate the behavior of such storage elements. In order to efficiently model storage elements, a designer will typically refer to a library that contains storage element simulation models for use in a design. These design storage elements are modeled by one or more simulator latches. Storage elements comprised of one or more simulator latches that are implemented within a design will be referred to hereinbelow as “design latches”. 
     As a consequence of utilizing multiple simulator latches to model a design latch, the process of propagating the input of a design latch to its output, which constitutes a design cycle, often requires more than one simulator cycle. A single design cycle is thus defined as comprising the number of simulator cycles required to propagate a set of values from one set of storage elements to the next. 
     In other circumstances, a simulation model may consist of distinct portions that are clocked at differing frequencies. For example, a microprocessor core connected to a bus interface unit, may operate at a higher frequency and than the bus interface unit. Under these circumstances, the higher frequency portion of the design will require one or more simulator cycles, say N cycles, to simulate a single design cycle. The lower frequency portion of the design will require a multiple of N simulator cycles in order to simulate a design cycle for the lower frequency portion. This multiple is equal to the ratio of the frequency of the higher speed design portion to the frequency of the lower speed design portion. It is often the case that certain portions of the logic can be run at a number of differing frequencies that are selectable at the beginning of a simulation run. Such logic, with a run-time selectable frequency of operation, presents unique challenges for monitoring count events. 
     With reference now to FIG. 6A, there is depicted a gate level representation of exemplary logic for one counter of counters  421  within instrumentation logic block  420  depicted in FIG.  4 B. Each counter of  421  is represented by a multi-bit simulator latch  600 . Simulator latch  600  is initialized by the simulation runtime environment to a value of zero at the beginning of a simulation run. Simulator latch  600  is updated every simulator cycle and is driven by multiplexor  601 . Multiplexor  601 , controlled by selector signal  602 , selects between signal  603 , the current value of simulator latch  600 , and signal  605 , the current value of simulator latch  600  incremented by 1 by incrementor  604 , to serve as the next cycle value for simulator latch  600 . By selecting signal  605 , multiplexor  601  causes the counter value within simulator latch  600  to be incremented when a count event occurs. It should be noted, however, that simulator latch  600  is updated every simulator cycle irrespective of the number of simulator cycles that correspond to a design cycle for the logic being monitored by a counting instrument. Logical AND gate  606  and simulator latch  607  serve to disable the monitoring of count event signal  609  in a manner similar to that described above for the disabling of failure events. Signal  608  is count event signal  609  further qualified by signal  610  by means of logical AND gate  611 . 
     Signal  610  ensures that simulator latch  600  will be incremented, if count event signal  609  is active, only once per design cycle for the logic being monitored by a counting instrument irrespective of the number of simulation cycles utilized to model the design cycle. This clocking normalization is necessary to ensure that the event counts recorded in counters  421  correspond to the number of design cycles rather than the number of simulator cycles in which the event occurred. 
     For example, if an event occurs in two design cycles, wherein a single design cycle requires four simulator cycles, it is preferable for the event counter to reflect a value of two rather than a value of eight, as would occur if the counter were allowed to update in every simulator cycle. 
     Furthermore, if the count event being monitored is within a portion of the logic with a run-time selectable frequency of operation, it is useful to have the count registers reflect the number of occurrences of the event in terms of design cycles. For example, consider a circumstance where a count event occurs twice during two different simulation runs. In the first run, assume that four simulator cycles are needed to represent each design cycle. Further assume in the second run that twelve simulator cycles are necessary to represent each design cycle. Without a clocking normalization mechanism, the first run would indicate that the event occurred eight times (two occurrences times four simulator cycles per occurrence) and the second run would indicate that the event occurred twenty-four times (two occurrences times twelve simulator cycles per occurrence) when in fact the event actually only occurred twice in both simulation runs. Therefore, it would be advantageous to limit the updating of counters  421  such that each counter is only updated once per design cycle irrespective of the number of simulator cycles, possibly variable at run-time, needed to represent a design cycle. 
     In simulation models in which multiple simulator cycles are utilized to represent a single design cycle, explicit clocking signals are utilized within the model to control the updating of the various design storage elements. These clocking signals specify in which simulator cycles the simulator latches representing design storage elements are allowed to update. A clocking signal is asserted high for some contiguous number of simulator cycles either at the beginning or end of the design cycle and asserted low for the remaining simulator cycles within the design cycle. If the clocking signal is asserted high during the beginning of the design cycle, the clock is referred to as a “high-active” clock and, likewise, if the clocking signal is asserted low during the beginning of the design cycle, the clock is referred to as a “low-active” clock. 
     Each count event signal has an associated qualifying signal as specified by counter declaration comments  455  as described above. Typically, these qualifying signals are connected to the clocking signals within the design responsible for updating the storage elements within the portion of logic monitored by the count event. The qualifying signal for the count event for simulator latch  600 , qualifying signal  612 , is depicted as a high-active qualifier signal. Qualifying signal  612  is processed by simulator latch  613  and logical AND gate  614 , to produce signal  610  which is active high for one and only one simulator cycle within the design cycle delineated by qualifying signal  612 . 
     Turning now to FIG. 6B there is illustrated a simplified timing diagram that demonstrates operation of simulator latch  613  and logical AND gate  614  assuming clocking qualifying signal  612  is a high active clocking signal of fifty percent duty cycle for a design cycle that occurs over a 10-simulation cycle period. Signal  615 , the output of simulator latch  613 , is qualifying signal  612  delayed by one simulator cycle. Signal  615  is inverted and logically ANDed with qualifying signal  612  to produce signal  610 , a high-active pulse that is asserted for the first simulator cycle of the design cycle. In a similar fashion, if the qualifying clock signal is low active, qualifying signal  612  would be inverted and signal  615  would be uninverted by logical AND gate  614 . This would produce a single simulator cycle active high pulse during the first simulator cycle of the design cycle. Qualifying signal  610 , by qualifying count event signal  609  by means of logical AND gate  611 , insures that counter  600  is incremented only once per design cycle irrespective of the number of simulator cycles utilized to represent a design cycle. 
     In contrast to cycle simulators, another class of simulators know as “event-driven” simulators is commonly utilized. In an event driven simulator, time is modeled in a more continuous manner. Each rising or falling edge of a signal or storage element within a design is modeled with specific regard to the physical time at which the signal transition occurred. In such simulators, the simulator latches operate in a slightly different manner than for a cycle based simulator. A simulator latch in an event driven simulator is controlled directly by a clocking signal. A new value is loaded into the simulator latch on either the rising or falling edge of the clocking signal (called a “positive-edge triggered” latch and a “negative-edge triggered” latch respectively). To practice the current invention within an event driven simulator, latch  613  and logical gates  614  and  611  are unnecessary. Rather, counter latch  600  is replaced by a positive or negative edge triggered simulator latch based on the polarity of qualifying signal  612 . Qualifying signal  612  is connected directly to simulator latch  600  and directly controls the updates of counter latch  600  insuring that the latch is updated only once per design cycle. 
     While the invention has been particularly shown as described with reference to a preferred embodiment, it will be understood by those skilled in the art that various changes in form and detail may be made therein without departing from the spirit and scope of the invention. One of the embodiments of the invention can be implemented as sets of instructions resident in random access memory  28  of one or more computer systems configured generally as described in FIG.  1  and FIG.  2 . Until required by computer system  10 , the set of instructions may be stored in another computer readable storage device, such as disk drive  33  or in a removable storage device such as an optical disk for eventual use in a CD-ROM drive or a floppy disk for eventual use in a floppy disk drive. The set of instructions may be referred to as a computer program product. Further, the set of instructions can be stored in the memory of another computer and transmitted over a local area network or a wide area network, such as the Internet, when desired by the user. It is therefore contemplated that such modifications can be made without departing from the spirit or scope of the present invention as defined in the appended claims.