C-API instrumentation for HDL models

CROSS REFERENCE TO RELATED APPLICATIONS

[0001] The present application is related to the following co-pending U.S. patent application: U.S. patent application Ser. No. ______ (Docket No. AUS920010008US1) filed on ______, titled “Dynamic Loading Of C-API HDL Model Instrumentation”. The above-mentioned patent application is assigned to the assignee of the present invention and is incorporated herein by reference.

BACKGROUND OF THE INVENTION

[0002] 1. Technical Field

[0003] The present invention relates in general to designing and simulating digital devices, modules and systems in a distributed simulation environment. In particular, the present invention relates to a method and system that improve a distributed simulation environment to allow for efficient monitoring and utilization of instrumentation events embedded with a simulation model. More particularly, the present invention relates to instrumenting testcase execution processing of a hardware description language (HDL) model using a simulation control program.

[0004] 2. Description of the Related Art

[0005] 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.

[0006] 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.

[0007] 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, typically attached to a general purpose computer, 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”.

[0008] Usually, software simulators perform a very large number of calculations and operate slowly from the user'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.

[0009] It is often the case that complex instrumentation events occur over many cycles and are composed of temporally complex interactions of a large number of signals within the given simulation model. Detecting such instrumentation events typically requires a complex functionality that necessitates a correspondingly complex modeling data structure. In such a circumstance, using HDL code or unconventional comments to create the necessary instrumentation logic can be difficult and inefficient.

[0010] In general, the instrumentation functionality required to detect such complex instrumentation events is usually more effectively created utilizing a high-level programming language such as C or C++. High-level programming languages typically provide more direct support for complex data structures and provide features such as dynamic memory allocation, among others, that allow for the more efficient generation of functionality suited to the detection of complex instrumentation events. Furthermore, simulation engineers are often not primarily conversant in HDLs, but instead rely on high-level programming languages such as C or C++.

[0011] It would therefore be advantageous to provide a means by which to generate and process instrumentation events, hereafter referred to as RTX instrumentation events, under RTX control utilizing a high-level language such as C or C++. Such a means would enable simulation engineers to more efficiently generate complex instrumentation events with the additional flexibility inherent in high-level programming languages.

SUMMARY OF THE INVENTION

[0012] A method and system are disclosed for instrumenting testcase execution processing of a hardware description language (HDL) model using a simulation control program. In accordance with the method of the present invention, a set name application program interface (API) entry point is called wherein the set name API entry point includes program instructions for naming a simulation control program in association with testcase execution of the HDL model. A create event API entry point is called, wherein the create event API entry point includes an event identifier input parameter which identifies a testcase execution event with respect to the named simulation control program. In response to executing a testcase simulation cycle, signal values are retrieved from the HDL model into an instrumentation code block, wherein the instrumentation code block includes program instructions for processing the retrieved signals to detect whether the testcase execution event has occurred during the testcase simulation cycle.

[0013] All objects, features, and advantages of the present invention will become apparent in the following detailed written description.

BRIEF DESCRIPTION OF THE DRAWINGS

[0014] 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:

[0015]FIG. 1 is a pictorial representation of a data processing system;

[0016]FIG. 2 depicts a representative hardware environment of the data processing system illustrated in FIG. 1;

[0017]FIG. 3A is a simplified block diagram illustrating a digital design entity that may be instrumented in accordance with the teachings of the present invention;

[0018]FIG. 3B is a diagrammatic representation depicting a simulation model that may be instrumented in accordance with the teachings of the present invention;

[0019]FIG. 3C is a flow diagram illustrating of a model build process that may be implemented in accordance with the teachings of the present invention;

[0020]FIG. 3D is a block diagram depicting data structures that may be instrumented in accordance with the teachings of the present invention;

[0021]FIG. 4A is a simplified block diagram representative of an instrumentation entity;

[0022]FIG. 4B is a simplified block diagram of a simulation model instrumented in accordance with the teachings of the present invention;

[0023]FIG. 4C illustrates exemplary sections of HDL syntax that maybe utilized in accordance with the teachings of the present invention;

[0024]FIG. 4D is a flow diagram depicting a model build process in accordance with the teachings of the present invention;

[0025]FIG. 4E is a block diagram representation of memory data structures constructed in accordance with the teachings of the present invention;

[0026]FIG. 5A is a logic diagram representation of a runtime disable mechanism in accordance with the teachings of the present invention;

[0027]FIG. 5B is a block diagram representation 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;

[0028]FIG. 6A is 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;

[0029]FIG. 6B is a simplified timing diagram illustrating automatic clocking adjustment of counting instrumentation;

[0030]FIG. 7 depicts an alternative counting means that may be employed for counting events detected by instrumentation entities in accordance with the teachings of the present invention;

[0031]FIG. 8A illustrates a conventional finite state machine that may be instrumented with an embedded checker in accordance with the teachings of the present invention;

[0032]FIG. 8B depicts a conventional finite state machine design entity;

[0033]FIG. 8C illustrates a hardware description language file including embedded instrumentation in accordance with the teachings of the present invention;

[0034]FIG. 9 depicts a hardware description language design entity included embedded instrumentation in accordance with the teachings of the present invention;

[0035]FIG. 10A is a block diagram illustrating a simulation model containing a number of design and instrumentation entities;

[0036]FIG. 10B depicts a data structure for declaring an event within a simulation model in accordance with one embodiment of the present invention;

[0037]FIG. 10C illustrates a list of extended event data structures for the simulation model in FIG. 10A;

[0038]FIG. 10D depicts a data structure for declaring an event within a simulation model in accordance with an alternate embodiment of the present invention;

[0039]FIG. 11A is a block diagram illustrating a simulation model in which the hierarchical event processing of the present invention is applicable;

[0040]FIG. 11B depicts a set of input port mapping comments for performing hierarchical processing of simulation model events in accordance with a first embodiment of the present invention;

[0041]FIG. 11C illustrates a set of input port mapping comments for performing hierarchical processing of simulation model events in accordance with a second embodiment of the present invention;

[0042]FIG. 12A depicts a representative target design entity with an instrumentation entity containing random instrumentation logic implemented in accordance with the teachings of the present invention;

[0043]FIG. 12B illustrates an exemplary HDL file for implementing instrumentation logic within an HDL design entity in accordance with the teachings of the present invention;

[0044]FIG. 13A depicts an exemplary design entity containing a multi-bit simulation signal;

[0045]FIG. 13B illustrates a design entity wherein signal injection is implemented in accordance with the teachings of the present invention;

[0046]FIG. 13C depicts an exemplary HDL source file that describes instrumentation entity in accordance with the teachings of the present invention;

[0047]FIG. 13D illustrates an HDL design entity source code file wherein a set of random instrumentation comments implement the logic necessary for selectively overriding a simulation signal in accordance with the teachings of the present invention;

[0048]FIG. 14A is a block diagram depicting data content within a main memory during a simulation run of a simulation model;

[0049]FIG. 14B is a block diagram illustrating data contents of a main memory during a simulation run in accordance with the teachings of the present invention;

[0050]FIG. 14C depicts an exemplary HDL source code file that describes an instrumentation entity in accordance with the teachings of the present invention;

[0051]FIG. 15 illustrates an eventlist file <b>1660</b> for the count events of simulation model <b>1000</b> shown in FIG. 10A;

[0052]FIG. 16B depicts a batch simulation farm in which a preferred embodiment of the present invention may be implemented;

[0053]FIG. 16C is a flow diagram illustrating a progression of events from the creation of a specific simulation model to the removal of that model from batch simulation farm and instrumentation server in accordance with a preferred embodiment of the present invention;

[0054]FIG. 16D is a flow diagram depicting steps performed during execution of a simulation job within a batch simulation farm in accordance with a preferred embodiment of the present invention;

[0055]FIG. 17A is a block diagram illustrating the active data content within a main memory during a simulation run of a simulation model within a batch simulation farm environment in accordance with a preferred embodiment of the present invention;

[0056]FIG. 17B depicts an aggregate data packet delivered by an API entry point routine to an instrumentation server in accordance with a preferred embodiment of the present invention;

[0057]FIG. 17C is a flow diagram illustrating a process by which the correctness of aggregate data packets received by an batch simulation farm instrumentation server is validated in accordance with a preferred embodiment of the present invention;

[0058]FIG. 18A illustrates memory contents of a simulation client during execution of a simulation job in accordance with a preferred embodiment of the present invention;

[0059]FIG. 18B is a flow diagram depicting steps performed by an API entry point in accessing a batch simulation farm instrumentation server to obtain a disable failure list in accordance with a preferred embodiment of the present invention;

[0060]FIG. 19A is a block diagram illustrating memory contents of a simulation client at the conclusion of a simulation job in accordance with a preferred embodiment of the present invention;

[0061]FIG. 19B is a flow diagram depicted a process by which a batch simulation farm instrumentation server processes fail event aggregate data packets in accordance with a preferred embodiment of the present invention;

[0062]FIG. 20A is a block diagram illustrating the active memory content of a simulation client during simulation model testing in which count event data delivered to an instrumentation server within a batch simulation farm environment in accordance with a preferred embodiment of the present invention;

[0063]FIG. 20B depicts an aggregate count event packet delivered by an API entry point routine to an instrumentation server in accordance with a preferred embodiment of the present invention;

[0064]FIG. 20C illustrates a count storage file maintained within a batch simulation farm instrumentation server in accordance with a preferred embodiment of the present invention;

[0065]FIG. 20D depicts a counter directory/subdirectory structure maintained within a batch simulation farm instrumentation server in accordance with a preferred embodiment of the present invention;

[0066]FIG. 20E illustrates a count event entity translation table derived from multiple entity list files in accordance with a preferred embodiment of the present invention;

[0067]FIG. 20F depicts a system applicable within a batch simulation farm for storing and accessing count event data in accordance with a preferred embodiment of the present invention;

[0068]FIG. 20G illustrates a hierarchical and a non-hierarchical basic counter output report in accordance with the teachings of the present invention;

[0069]FIG. 20H depicts a user-modifiable counter query data structure applicable to the counter storage and access system shown in FIG. 20F;

[0070]FIG. 20I is a flow diagram illustrating steps performed by a counter query engine program to produce a basic counter output report from a user query in accordance with a preferred embodiment of the present invention;

[0071]FIG. 21A depicts a system applicable within a batch simulation farm for storing and accessing trends in count event data in accordance with a preferred embodiment of the present invention;

[0072]FIG. 21B illustrates file and instruction means required for count difference analysis in accordance with a preferred embodiment of the present invention;

[0073]FIG. 21C is a high-level flow diagram depicting steps performed within a batch simulation farm instrumentation server during count difference analysis processing in accordance with a preferred embodiment of the present invention;

[0074]FIG. 21D is a flow diagram illustrating steps performed within a batch simulation farm instrumentation server during counter output report comparison processing in accordance with a preferred embodiment of the present invention;

[0075]FIG. 22A illustrates elements within a batch simulation farm utilized in collecting harvest event testcases in accordance with a preferred embodiment of the present invention;

[0076]FIG. 22B is a flow diagram depicting steps performed in collecting harvest event testcases in accordance with a preferred embodiment of the present invention;

[0077]FIG. 22C is a flow diagram illustrating the operation of a harvest manager program during harvest event testcase collection in accordance with a preferred embodiment of the present invention;

[0078]FIG. 23A depicts additional elements within an instrumentation server and a harvest testcase server that are utilized in resolving inconsistencies between a master harvest hit table and a harvest testcase bucket in accordance with a preferred embodiment of the present invention;

[0079]FIG. 23B illustrates the data structure and content of a harvest testcase list and a master harvest hit table as they exist prior to the harvest annealing process of the present invention;

[0080]FIG. 23C is a flow diagram illustrating in further detail the steps performed by a harvest manager program to process annealing requests from a harvest testcase server in accordance with a preferred embodiment of the present invention;

[0081]FIG. 24A depicts data structure representations of API entry points designed to support the generation and operation of RTX instrumentation events in accordance with a preferred embodiment of the present invention;

[0082]FIG. 24B is a block diagram illustrating memory contents utilized during processing of a simulation job that employs RTX instrumentation events performed with respect to an HDL simulation model;

[0083]FIG. 24C is a flow diagram depicting steps performed by an RTX during the generation and processing of RTX instrumentation events in accordance with a preferred embodiment of the present invention;

[0084]FIG. 24D is a flow diagram illustrating in greater detail the operation of a trigger event API entry point in accordance with a preferred embodiment of the present invention;

[0085]FIG. 25A depicts a high-level block diagram representation of an HDL simulation model augmented with a design entitylist data structure in accordance with a preferred embodiment of the present invention;

[0086]FIG. 25B illustrates an instrumentation code module having designated program entrypoints;

[0087]FIG. 25C depicts data structure representations of API entry points designed to manage dynamically loading and calling instrumentation code modules in accordance with a preferred embodiment of the present invention;

[0088]FIG. 25D is a block diagram illustrating memory contents utilized during processing of a simulation job that employs instrumentation code modules processed with respect to an HDL simulation model in accordance with a preferred embodiment of the present invention;

[0089]FIG. 25E is a flow diagram depicting steps performed by an API entry point during loading and initialization of instrumentation code modules; and

[0090]FIG. 25F is a flow diagram illustrating steps performed by an API entry point to execute instrumentation code modules during each sequence of a main simulation processing loop.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT

[0091] The present invention provides for accurate and comprehensive monitoring of a digital circuit design in which a designer creates instrumentation modules utilizing the same hardware description language (HDL) as utilized for the design itself. HDLs, while suited to the needs of digital designers can also be effectively utilized for a number of checking functions. In accordance with the Method and System of the present invention, instrumentation modules are utilized to monitor specified design parameters while not becoming compiled as an integral part of the design itself. Furthermore, since the 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.

[0092] 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 <b>10</b> with which the present invention maybe advantageously utilized. As illustrated, data processing system <b>10</b> comprises a workstation <b>12</b> to which one or more nodes <b>13</b> are connected. Workstation <b>12</b> 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 <b>12</b> 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 <b>13</b> are comprised of a display device <b>14</b>, a keyboard <b>16</b>, and a mouse <b>20</b>. The ECAD software applications executed within workstation <b>12</b> preferably display a graphic user interface (GUI) within display screen <b>22</b> of display device <b>14</b> with which a digital circuit designer can interact using a keyboard <b>16</b> and mouse <b>20</b>. Thus, by entering appropriate inputs utilizing keyboard <b>16</b> and mouse <b>20</b>, the digital circuit designer is able to develop and verify a digital circuit design according to the method described further hereinbelow.

[0093]FIG. 2 depicts a representative hardware environment of data processing system <b>10</b>. Data processing system <b>10</b> is configured to include all functional components of a computer and its associated hardware. Data processing system <b>10</b> includes a Central Processing Unit (“CPU”) <b>24</b>, such as a conventional microprocessor, and a number of other units interconnected via system bus <b>26</b>. CPU <b>24</b> includes a portion of data processing system <b>10</b> 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 <b>24</b> 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 <b>10</b> can be implemented in a system unit such as workstation <b>12</b> of FIG. 1.

[0094] Data processing system <b>10</b> further includes random-access memory (RAM) <b>28</b>, read-only memory(ROM) <b>30</b>, display adapter <b>32</b> for connecting system bus <b>26</b> to display device <b>14</b>, and I/O adapter <b>34</b> for connecting peripheral devices (e.g., disk and tape drives <b>33</b>) to system bus <b>26</b>. RAM <b>28</b> 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 <b>28</b> can be accessed directly without having to work through from the beginning. ROM <b>30</b> 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.

[0095] Display device <b>14</b> provides the visual output of data processing system <b>10</b>. Display device <b>14</b> 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 <b>14</b> can be replaced with a liquid crystal display (LCD) based or gas plasma-based flat-panel display. Data processing system <b>10</b> further includes user interface adapter <b>36</b> for connecting keyboard <b>16</b>, mouse <b>20</b>, speaker <b>38</b>, microphone <b>40</b>, and/or other user interface devices, such as a touch-screen device (not shown), to system bus <b>26</b>. Speaker <b>38</b> 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 <b>10</b> for system failures, errors, and discrepancies. Communications adapter <b>42</b> connects data processing system <b>10</b> to a computer network. Although data processing system <b>10</b> 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.

[0096] Data processing system <b>10</b> also includes an interface that resides within a machine-readable media to direct the operation of data processing system <b>10</b>. Any suitable machine-readable media may retain the interface, such as RAM <b>28</b>, ROM <b>30</b>, a magnetic disk, magnetic tape, or optical disk (the last three being located in disk and tape drives <b>33</b>). Any suitable operating system and associated interface (e.g., Microsoft Windows) may direct CPU <b>24</b>. For example, the AIX operating system and AIX Windows windowing system can direct CPU <b>24</b>. The AIX operating system is IBM's implementation of the UNIX™ operating system. Other technologies also can be utilized in conjunction with CPU <b>24</b>, such as touch-screen technology or human voice control.

[0097] 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 <b>44</b> is connected to system bus <b>26</b>, and includes a control program <b>46</b>. Control program <b>46</b> resides within main memory <b>44</b>, and contains instructions that, when executed on CPU <b>24</b>, carries out the operations depicted in FIG. 4D and FIG. 4E described herein.

[0098] Simulated digital circuit design models are comprised of at least one and usually many sub-units referred to hereinafter as design entities. FIG. 3A is a block diagram representation of an exemplary design entity <b>300</b> in which the method and system of the present invention may be implemented. Design entity <b>300</b> is defined by a number of components: an entity name, entity ports, and a representation of the function performed by design entity <b>300</b>. 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.

[0099] Typically, ports are categorized as belonging to one of three distinct types: input ports, output ports, and bi-directional ports. Design entity <b>300</b> is depicted in as having a number of input ports <b>303</b> that convey signals into design entity <b>300</b>. Input ports <b>303</b> are connected to input signals <b>301</b>. In addition, design entity <b>300</b> includes a number of output ports <b>306</b> that convey signals out of design entity <b>300</b>. Output ports <b>306</b> are connected to a set of output signals <b>304</b>. Bi-directional ports <b>305</b> are utilized to convey signals into and out of design entity <b>300</b>. Bi-directional ports <b>305</b> are in turn connected to a set of bi-directional signals <b>309</b>. An entity, such as design entity <b>300</b>, 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. 3A) 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.

[0100] Finally, design entity <b>300</b> contains a body section <b>308</b> that describes one or more functions performed by design entity <b>300</b>. In the case of a digital design, body section <b>308</b> contains an interconnection of logic gates, storage elements, etc., in addition to instantiations of other entities. By instantiating an entity within another entity, a hierarchical description of an overall design is achieved. For example, a microprocessor may contain multiple instances of an identical functional unit. As such, the microprocessor itself will often be modeled as a single entity. Within the microprocessor entity, multiple instantiations of any duplicated functional entities will be present.

[0101] Referring now to FIG. 3B, there is illustrated a diagrammatic representation of an exemplary simulation model <b>329</b> that may be utilized in a preferred embodiment of the present invention. Simulation model <b>329</b> consists of multiple hierarchical entities. For visual simplicity and clarity, the ports and signals interconnecting the entities within simulation model <b>329</b> have not been explicitly shown. In any model, one and only one entity is the so-called “top-level entity”. A top-level entity <b>320</b>, is that entity which encompasses all other entities within simulation model <b>329</b>. That is to say, top-level entity <b>320</b> instantiates, either directly or indirectly, all descendant entities within a design. Simulation model <b>329</b> consists of top-level entity <b>320</b> which directly instantiates two instances, <b>321</b><i>a </i>and <b>321</b><i>b</i>, of an FXU entity <b>321</b> and a single instance of an FPU entity <b>322</b>. Each instantiation has an associated description, which contains an entity name and a unique instantiation name. For top-level entity <b>320</b>, description <b>310</b> is labeled “TOP:TOP”. Description <b>310</b> includes an entity name <b>312</b>, labeled as the “TOP” preceding the colon, and also includes an instantiation name <b>314</b>, labeled as the “TOP” following the colon.

[0102] It is possible for a particular entity to be instantiated multiple times as is depicted with instantiations <b>321</b><i>a </i>and <b>321</b><i>b </i>of FXU entity <b>321</b>. Instantiations <b>321</b><i>a </i>and <b>321</b><i>b </i>are distinct instantiations of FXU entity <b>321</b> with instantiation names FXU0 and FXU1 respectively. Top-level entity <b>320</b> is at the highest level within the hierarchy of simulation model <b>329</b>. An entity that instantiates a descendant entity will be referred to hereinafter as an “ancestor” of the descendant entity. Top-level entity <b>320</b> is therefore the ancestor that directly instantiates FXU entity instantiations <b>321</b><i>a </i>and <b>321</b><i>b</i>. At any given level of a simulation model hierarchy, the instantiation names of all instantiations must be unique.

[0103] In addition to FXU entity instantiations <b>321</b><i>a </i>and <b>321</b><i>b</i>, top-level entity <b>320</b> directly instantiates a single instance of a FPU entity <b>322</b> having an entity name FPU and instantiation name FPU0. 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 <b>322</b> (instantiation name FPU0, entity name FPU).

[0104] Within instantiation <b>321</b><i>a </i>of FXU entity <b>321</b>, single instance entities <b>325</b><i>a </i>and <b>326</b><i>a </i>of entity A <b>325</b> and entity B <b>326</b> respectively, are directly instantiated. Similarly instantiation <b>321</b><i>b </i>of the same FXU entity contains instantiations <b>325</b><i>b </i>and <b>326</b><i>b </i>of entity A <b>325</b> and entity B <b>326</b> respectively. In a similar manner, instantiation <b>326</b><i>a </i>and instantiation <b>326</b><i>b </i>each directly instantiate a single instance of entity C <b>327</b> as entities <b>327</b><i>a </i>and <b>327</b><i>b </i>respectively. The nesting of entities within other entities can continue to an arbitrary level of complexity provided that all entities instantiated, whether singly 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.

[0105] 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 instantiation names proceeding from the top-level entity instantiation name. For example, the instantiation identifier of instantiation <b>327</b><i>a </i>of entity C <b>327</b> within instantiation <b>321</b><i>a </i>of FXU entity <b>321</b> is “TOP.FXU0.B.C”. This identifier serves to uniquely identify each instantiation within a simulation model.

[0106] Referring now to FIG. 3C, there is depicted a flow diagram of a model build process which may be implemented in a preferred embodiment of the present invention. The process begins with one or more design entity HDL source code files <b>340</b> and, potentially, one or more design entity intermediate format files <b>345</b>, hereinafter referred to as “proto files” <b>345</b>, available from a previous run of an HDL compiler <b>342</b>. HDL compiler <b>342</b> processes HDL file(s) <b>340</b> 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. For each of HDL files <b>340</b> during the compilation process, HDL compiler <b>342</b>, examines proto files <b>345</b> to determine if a previously compiled proto file is available and consistent. If such a file is available and consistent, HDL compiler <b>342</b> will not recompile that particular file, but will rather refer to an extant proto file. If no such proto file is available or the proto file is not consistent, HDL compiler <b>342</b> explicitly recompiles the HDL file <b>340</b> in question and creates a proto file <b>344</b>, 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 <b>348</b>. Incremental compilation is described in further detail hereinbelow. Once created by HDL compiler <b>342</b>, Proto files <b>344</b> are available to serve as proto files <b>345</b> in subsequent compilations.

[0107] In addition to proto files <b>344</b>, HDL compiler <b>342</b> also creates two sets of data structures, design entity proto data structures <b>341</b> and design entity instance data structures <b>343</b>, in memory <b>44</b> of computer system <b>10</b>. Design entity proto data structures <b>341</b> and design entity instance data structures <b>343</b>, serve as a memory image of the contents of a simulation executable model <b>348</b>. Data structures <b>341</b> and <b>343</b> are passed, via memory <b>44</b>, to a model build tool <b>346</b> that processes data structures <b>341</b> and <b>343</b> into simulation executable model <b>348</b>.

[0108] It will be assumed hereinafter 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.

[0109] 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 <b>320</b> 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.

[0110] 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 <b>325</b> and B entity <b>326</b>. Furthermore, B entity <b>326</b> directly instantiates C entity <b>327</b>. Therefore, FXU entity <b>321</b> instantiates, directly or indirectly, A entity <b>325</b>, B entity <b>326</b> and C entity <b>327</b>. Those entities, that are directly or indirectly instantiated by another entity, will be referred to hereinafter as “descendants”. The descendants of top level entity <b>320</b> are FXU entity <b>321</b>, FPU entity <b>322</b>, A entity <b>325</b>, B entity <b>326</b>, and C entity <b>327</b>. It can be seen that each entity has a unique set of descendants and that each time an entity is instantiated, a unique instance of the entity and its descendants is created. Within simulation model <b>329</b>, FXU entity <b>321</b> is instantiated twice, FXU:FXU0 <b>321</b><i>a </i>and FXU:FXU1 <b>321</b><i>b</i>, by top-level entity <b>320</b>. Each instantiation of FXU entity <b>321</b> creates a unique set of instances of the FXU, A, B, and C entities.

[0111] 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 having date and time stamps of the entity itself and the entity's descendants. Referring again to FIG. 3C, the BOM for an entity is stored in proto file <b>344</b> after compilation of the entity. Therefore, when HDL compiler <b>342</b> compiles a particular HDL source code file among HDL files <b>340</b>, a proto file <b>344</b> is generated that includes a BOM listing the HDL files <b>340</b> that constitute the entity and the entity'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 <b>33</b> of computer system <b>10</b> when the HDL file was being compiled.

[0112] If any of the HDL files constituting an entity or the entity's descendants is subsequently changed, proto file <b>344</b> will be flagged as inconsistent and HDL compiler <b>342</b> will recompile HDL file <b>340</b> on a subsequent re-compilation as will be described in further detail below. For example, going back to FIG. 3B, the HDL files referenced by the BOM of FXU entity <b>321</b> 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 <b>320</b> are TOP.vhdl, FXU.vhdl, A.vhdl, B.vhdl, C.vhdl, and FPU.vhdl with appropriate date and time stamps.

[0113] Returning to FIG. 3C, HDL compiler <b>342</b> creates an image of the structure of a simulation model in main memory <b>44</b> of computer system <b>10</b>. This memory image is comprised of the following components: “proto” data structures <b>341</b> and “instance” data structures <b>343</b>. 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) <b>344</b>). Proto files <b>344</b> are therefore on-disk representations of the in-memory proto data structure produced by HDL compiler <b>342</b>.

[0114] 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 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.

[0115] In order to incrementally compile a model efficiently, HDL compiler <b>342</b> follows a recursive method of compilation in which successive entities of the model are considered and loaded from proto files <b>345</b> 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 <b>345</b>, HDL compiler <b>342</b> recursively examines the descendants of the entity, loads those descendant entities available from proto file(s) <b>345</b> and creates, as needed, proto files <b>344</b> for those descendants that are inconsistent with proto files <b>345</b>. Psuedocode for the main control loop of HDL compiler <b>342</b> 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). <tables id="TABLE-US-00001" num="1"><table frame="none" colsep="0" rowsep="0"><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="21PT" align="left" /><colspec colname="1" colwidth="154PT" align="left" /><colspec colname="2" colwidth="42PT" align="center" /><thead><row><entry /><entry /></row><row><entry /><entry namest="OFFSET" nameend="2" align="center" rowsep="1" /></row></thead><tbody valign="top"><row><entry /><entry>process_HDL_file(file)</entry><entry> 5</entry></row><row><entry /><entry>{</entry><entry>10</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="35PT" align="left" /><colspec colname="1" colwidth="112PT" align="left" /><colspec colname="2" colwidth="70PT" align="center" /><tbody valign="top"><row><entry /><entry>if (NOT proto_loaded(file)) {</entry><entry>15</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="49PT" align="left" /><colspec colname="1" colwidth="98PT" align="left" /><colspec colname="2" colwidth="70PT" align="center" /><tbody valign="top"><row><entry /><entry>if (exists_proto_file(file)</entry><entry>20</entry></row><row><entry /><entry>AND check_bom(file)) {</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="63PT" align="left" /><colspec colname="1" colwidth="84PT" align="left" /><colspec colname="2" colwidth="70PT" align="center" /><tbody valign="top"><row><entry /><entry>load_proto(file);</entry><entry>25</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="49PT" align="left" /><colspec colname="1" colwidth="98PT" align="left" /><colspec colname="2" colwidth="70PT" align="center" /><tbody valign="top"><row><entry /><entry>} else {</entry><entry>30</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="63PT" align="left" /><colspec colname="1" colwidth="84PT" align="left" /><colspec colname="2" colwidth="70PT" align="center" /><tbody valign="top"><row><entry /><entry>parse_HDL_file(file)</entry><entry>35</entry></row><row><entry /><entry>for (all instances in file) {</entry><entry>40</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="77PT" align="left" /><colspec colname="1" colwidth="70PT" align="left" /><colspec colname="2" colwidth="70PT" align="center" /><tbody valign="top"><row><entry /><entry>process_HDLfile</entry><entry>45</entry></row><row><entry /><entry>(instance);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="63PT" align="left" /><colspec colname="1" colwidth="84PT" align="left" /><colspec colname="2" colwidth="70PT" align="center" /><tbody valign="top"><row><entry /><entry>}</entry><entry>50</entry></row><row><entry /><entry>create_proto(file);</entry><entry>55</entry></row><row><entry /><entry>write_proto_file(file);</entry><entry>60</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="49PT" align="left" /><colspec colname="1" colwidth="98PT" align="left" /><colspec colname="2" colwidth="70PT" align="center" /><tbody valign="top"><row><entry /><entry>}</entry><entry>65</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="35PT" align="left" /><colspec colname="1" colwidth="112PT" align="left" /><colspec colname="2" colwidth="70PT" align="center" /><tbody valign="top"><row><entry /><entry>}</entry><entry>70</entry></row><row><entry /><entry>create_instance(file):</entry><entry>75</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="21PT" align="left" /><colspec colname="1" colwidth="126PT" align="left" /><colspec colname="2" colwidth="70PT" align="center" /><tbody valign="top"><row><entry /><entry>}</entry><entry>80</entry></row><row><entry /><entry namest="OFFSET" nameend="2" align="center" rowsep="1" /></row></tbody></tgroup></table></tables>

[0116] When compiler <b>342</b> is initially invoked, no proto data structures <b>341</b> or instance data structures <b>343</b> are present in memory <b>44</b> of computer system <b>10</b>. 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 <b>44</b> 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 without any proto data structures loaded into memory <b>44</b>. If a matching proto data structure is present in memory <b>44</b>, instance data structures for the current entity and the current entity's descendants, if any, are created as necessary in memory <b>44</b> by routine create_instance( ) (line 75).

[0117] However, if a matching proto data structure is not present in memory <b>44</b>, control passes to line 20 where routine exists_proto_file( ) examines proto files <b>345</b> 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 whether proto file <b>345</b> is consistent. In order to determine whether 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 <b>44</b>, thus creating proto data structures <b>341</b> for the current entity and the current entity's descendants, if any. The construction of process_HDL_file( ) ensures that once a proto file has been verified as consistent, all of its descendant proto files, if any, are also consistent.

[0118] If 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 <b>341</b> and proto data files <b>344</b> of all 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 <b>44</b> by routine create_proto( ). Control then passes to line 60 where a new proto file <b>344</b>, including an associated BOM, is written to disk <b>33</b> by routine write_proto_file( ). Finally, control passes to line 75 where routine create_instance( ) creates instance data structures <b>343</b> 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 <b>341</b> and instance data structures <b>343</b>.

[0119] With reference now to FIG. 3D there is depicted a block diagram representing compiled data structures which may be implemented in a preferred embodiment of the present invention. Memory <b>44</b> contains proto data structures <b>361</b>, one for each of the entities referred to in simulation model <b>329</b>. In addition, instantiations in simulation model <b>329</b> are represented by instance data structures <b>362</b>. Instance data structures <b>362</b> are connected by means of pointers indicating the hierarchical nature of the instantiations of the entities within simulation model <b>329</b>. Model build tool <b>346</b> in FIG. 3C processes the contents of memory <b>44</b> into memory data structures in order to produce simulation executable model <b>348</b>.

[0120] In order to instrument simulation models, the present invention makes use of entities known as “instrumentation entities,” which are in contrast to the entities constituting a design which are referred to herein as “design entities”. As with design entities, instrumentation 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”.

[0121] With reference now to FIG. 4A, there is illustrated a block diagram representation of an instrumentation entity <b>409</b>. Instrumentation entity <b>409</b> includes a number of input ports <b>400</b> that are connected to signals <b>401</b> within a target entity (not depicted in FIG. 4A). A body section <b>402</b> contains logic necessary to detect occurrences of specified conditions within the target entity and generate simulation model “events” with respect to signals <b>401</b>. Three distinct types of events may be generated: “count” events, “fail” events, and “harvest” events, each described below in turn. Body section <b>402</b> contains internal logic for detecting occurrences of conditions precipitating generation of these events. A set of multi-bit output ports <b>403</b>, <b>404</b>, and <b>405</b> are connected to external instrumentation logic (depicted in FIG. 4B) by means of external signals <b>406</b>, <b>407</b>, and <b>408</b>. Output ports <b>403</b>, <b>404</b>, and <b>405</b> thus provide the connection from the internal logic in body section <b>402</b> to the external instrumentation logic which is utilized to indicate the occurrence of count, failure and harvest events.

[0122] A failure event is a sequence of signal values that indicate a failure in the correct operation of the simulation model. Each instrumentation entity monitors the target entity for any desired number of failure events. Each occurrence of a failure event is assigned to a particular signal bit on output port <b>403</b>. Logic within body section <b>402</b> produces an active high pulse on a specified bit of signal <b>403</b> when a failure condition is detected. Such activation of signal <b>403</b> is defined as a failure event. This error indication is conveyed by means of external signal <b>406</b> to external instrumentation logic (depicted in FIG. 4B as external instrumentation logic block <b>420</b>), which flags the occurrence of the failure event.

[0123] 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. 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 <b>405</b>. Logic block <b>402</b> contains the logic necessary to detect the occurrence of the desired count events and produces an active high pulse on the specified bit of signal <b>405</b> when a count event is detected. This count indication is conveyed by means of external signal <b>408</b> to instrumentation logic, which contains counters utilized to record the number of occurrences of each count event.

[0124] The third event type, a harvest event, is a sequence of signal values that indicate the occurrence of a specific operative circumstance, which would be advantageous to be able to reproduce. When a harvest event occurs, a register within an external instrumentation logic block 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. The details of the simulation run can thus be saved in order to recreate the specific circumstance monitored by the harvest event. Logic block <b>402</b> contains the logic necessary to detect the harvest events.

[0125] Each instrumentation entity can detect any desired number of harvest events that are each assigned to a particular signal bit on output port <b>404</b>. Logic within block <b>402</b> produces an active high pulse on the specified bit of signal <b>404</b> when a harvest event is detected. This harvest event detection is conveyed by means of external signal <b>407</b> to external instrumentation logic that contains a register and flag for each harvest event. The register is utilized to record at which point in the simulation run the harvest event occurred, and the flag is utilized to indicate the occurrence.

[0126] With reference now to FIG. 4B, wherein is depicted a block diagram representation of simulation model <b>329</b> instrumented in accordance with the teachings of the present invention. As can be seen in FIG. 4B, an instance <b>410</b> and an instance <b>411</b> of an instrumentation entity FXUCHK are utilized to monitor instances <b>321</b><i>a </i>and <b>321</b><i>b </i>of an FXU entity. For each FXU instantiations of <b>321</b><i>a </i>and <b>321</b><i>b</i>, an FXUCHK instantiation, <b>410</b> and <b>411</b> respectively, is automatically generated by the mechanism of the present invention. In a similar fashion, instrumentation entity FPUCHK <b>412</b> is instantiated to monitor FPU entity <b>322</b>.

[0127] As depicted in FIG. 4B, entity FXUCHK monitors a signals Q <b>372</b>, a signal R <b>376</b>, and a signal S <b>374</b> within each of instances <b>321</b><i>a </i>and <b>321</b><i>b </i>of the FXU entity. Signal Q <b>372</b>, is a signal within the instances <b>325</b><i>a </i>and <b>325</b><i>b </i>of descendant entity A. Likewise, signal S <b>374</b> is a signal within descendant entity C that resides within descendant entity B. Finally, signal R <b>376</b> occurs directly within FXU entity <b>321</b>. Although an instrumentation entity may monitor any signal within a target entity or the target entity's descendent entities, signals outside the target entity cannot be monitored.

[0128] Each instrumentation entity is connected by means of fail, count, and harvest signals to instrumentation logic block <b>420</b> containing logic for recording occurrences of each of the three event types. For the count events monitored in simulation model <b>329</b>, a set of counters <b>421</b> is utilized to count the number of occurrences of each count event. In a similar manner, a set of flags <b>424</b> is utilized to record the occurrence of failure events. Finally, a set of counters <b>422</b> and flags <b>423</b> are combined and utilized to record the point at which a harvest event occurs and its occurrence, respectively. In one embodiment of the present invention, a cycle number is captured and stored utilizing counters <b>422</b> and flags <b>423</b> to record a harvest event.

[0129] To facilitate instantiation and connection of instrumentation entities, instrumentation entity HDL source code files include a specialized comment section, hereinafter referred to as “instrumentation entity description”, that indicates the target entity, the signals within the target entity to be monitored, and information specifying types of events to be monitored.

[0130] With reference now to FIG. 4C, there is illustrated an exemplary HDL file <b>440</b> that describes instrumentation entity FXUCHK depicted in FIG. 4B. HDL file <b>440</b> 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 comments. The method and system of the present invention utilize comments of a non-conventional form to indicate information about an instrumentation entity. FIG. 4C depicts one embodiment of the present invention in which comments begin with two exclamation points in order to distinguish these comments from conventional comments in instrumentation HDL file <b>440</b>. It will be appreciated by those skilled in the art that the exemplary syntax utilized in FIG. 4C for the provision of unconventional comments is but one of many possible formats.

[0131] Within HDL file <b>440</b>, the I/O ports of a FXUCHK entity are declared in entity declaration <b>450</b>. Within entity declaration <b>450</b>, 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, <b>374</b>, signal Q, <b>372</b>, and signal R, <b>376</b> respectively as described below. Input port, CLOCK, is also declared and will be connected to a signal, CLOCK, within the FXU entity. 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. 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 <b>420</b>.

[0132] A set of instrumentation entity descriptors <b>451</b> are utilized to provide information about the instrumentation entity. As illustrated in FIG. 4C, descriptor comments <b>451</b> may be categorized in a number of distinct sections: prologue and entity name declaration <b>452</b>, an input port map <b>453</b>, a set of failure message declarations <b>454</b>, a set of counter declarations <b>455</b>, a set of harvest declarations <b>456</b>, and an epilogue <b>457</b>.

[0133] The prologue and entity name <b>452</b> serve to indicate the name of the particular target entity that the instrumentation entity will monitor. Prologue and entity name declaration <b>452</b> also serves as an indication that the instrumentation entity description has begun. Specifically, the comment “--!! Begin” within prologue and entity name <b>452</b>, indicates that the description of an instrumentation entity has begun. The comment “--!! Design Entity: FXU” identifies the target entity which, in HDL file <b>440</b>, is design entity FXU. This declaration serves to bind the instrumentation entity to the target entity.

[0134] Input port map <b>453</b> 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.

[0135] In some cases a signal to be monitored lies within a descendant of a target entity. This is the case for signal S <b>374</b>, which is embedded within entity C which is a descendant of entity B <b>326</b> and target FXU entity <b>321</b>. Input port map <b>453</b> includes an identification string for signal S <b>374</b> which consists of 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 <b>453</b> for signal S <b>374</b> is therefore as follows:

[0136] --!! S_IN=&gt;B.C.S

[0137] This syntax allows an instrumentation entity to connect to any signal within the target entity or the target entity's descendant entities. A signal appearing on the top level of the target design entity, has no pre-pended entity names; and therefore, has the following signal mapping comment:

[0138] --!! R_IN=&gt;R

[0139] For signals on the top level of the target entity, a special connection method is provided. If the signal to be connected to has the same name as its corresponding signal in the port map of the instrumentation entity, no input port mapping comment is required and the signal will be automatically connected if no such comment is present. In other words, if the input port mapping comment is of the form:

[0140] --!! signal=&gt;signal

[0141] where signal is a legal signal name without periods (“.”), then the input port mapping comment is not required and the system of the present invention will automatically make the connect. It is also possible to provide comments of the form given above to explicitly denote the signal connection. This mechanism is only operative for signals on the top level of the target entity.

[0142] Failure message declarations <b>454</b> 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 unique event name and a failure message. This message may be output by the simulation run-time environment upon detecting a failure event. The unique failure event name is utilized to identify the specific failure event within the model. Each failure event signal may be declared by a comment of the form “--!! n: &lt;eventname&gt; “failure message”;” where n is an integer denoting the failure event to which the message is associated, &lt;eventname&gt; is the unique failure event name, and “failure message” is the message 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.

[0143] Counter declaration comments <b>455</b> 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 <b>421</b> FIG. 4B. The variable name provides a means to identify and reference the particular counter associated with a particular count event. Thus, 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 specify whether the qualifying signal will be a high active qualifying signal or a low active qualifying signal.

[0144] Harvest declarations <b>456</b> 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 unique event name and 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: &lt;eventname&gt; “harvest message”;” where n is an integer denoting which harvest event the message is to be associated with, &lt;eventname&gt; is the unique harvest event name 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.

[0145] Harvest messages and event names, fail messages and event names, and counter variable names for a simulation model are included in a simulation executable model and lists of all the events within the model are produced in separate files at model build time. In this manner, each simulation model includes the information for each event monitored and a separate file containing this information for each event is available. Furthermore, as will be described below, the model build process names each event within the model (count, fail and harvest) model in such a manner as to insure that each event has a unique name with certain useful properties.

[0146] Finally, epilogue comment <b>457</b> consists of a single comment of the form “--!! End;”, indicating the end of descriptor comments <b>451</b>. The remainder of instrumentation entity HDL file <b>440</b> that follows the I/O declarations described above, is an entity body section <b>458</b>. In entity body section <b>458</b>, 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.

[0147] In addition to descriptor comments <b>451</b>, 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 instrumentation entity and its 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”.

[0148] With reference now to FIG. 4D, there is depicted a model build process in accordance with the teachings of the present invention. In this model build process, instrumentation load tool <b>464</b> 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 <b>464</b> utilizes descriptor comments <b>451</b> within instrumentation HDL files <b>461</b> to create instance data structures for the instrumentation entities within a simulation model.

[0149] The model build process of FIG. 4D begins with design entity HDL files <b>340</b> and, potentially, one or more design entity proto files <b>345</b> (available from a previous run of HDL compiler <b>462</b>), instrumentation entity HDL files <b>460</b>, and potentially, one or more instrumentation entity proto files <b>461</b> (available from a previous run of HDL compiler <b>462</b>). HDL compiler <b>462</b>, processes design entity HDL files <b>340</b>, and instrumentation entity HDL files <b>460</b> 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 <b>462</b> loads proto data structures from design entity proto files <b>345</b> and instrumentation entity protos files <b>460</b>, if such proto files are available and consistent. If such proto files are not available or are not consistent, HDL compiler <b>462</b> compiles design entity HDL files <b>340</b> and instrumentation entity HDL files <b>460</b> in order to produce design entity proto files <b>344</b> and instrumentation entity proto files <b>468</b>. (design entity proto files <b>344</b> and instrumentation entity proto files <b>468</b> are available to serve as design entity proto files <b>345</b> and instrumentation entity proto files <b>460</b> respectively for a subsequent run of HDL compiler <b>462</b>).

[0150] In addition, HDL compiler <b>462</b> creates in-memory design proto data structures <b>463</b> and design instance data structures <b>465</b> for the design entities of a simulation model. HDL compiler <b>462</b> also creates in-memory instrumentation proto data structures <b>466</b> for the instrumentation entities of a simulation model.

[0151] In order to minimize processing overhead HDL compiler <b>462</b> neither reads nor processes descriptor comments <b>451</b>. However, HDL compiler <b>462</b> does recognize instrumentation entity instantiation comments within target entity HDL files. As such, HDL compiler <b>462</b> cannot create instance data structures instrumentation entity data structures <b>467</b>. The creation of instance data structures requires interconnection information contained within descriptor comments <b>451</b> not processed by HDL compiler <b>462</b>. HDL compiler <b>462</b> does, however, create instrumentation proto data structures <b>466</b>.

[0152] The in-memory design proto data structures <b>463</b>, design instance data structures <b>465</b>, and instrumentation entity proto data structures <b>466</b>, are processed by instrumentation load tool <b>464</b>. Instrumentation load tool <b>464</b> examines design entity proto data structures <b>463</b> and design entity instance data structures <b>465</b> to determine those design entities that are target entities. This examination is accomplished by utilizing a particular comment format as previously described.

[0153] All target entities that are loaded from design entity proto files <b>345</b> contain an instantiation for any associated instrumentation entity. Therefore, instrumentation load tool <b>464</b> merely creates an instance data structure <b>467</b> for any such instrumentation entity and passes, the unaltered design proto data structure <b>463</b> to instrumented design proto data structure <b>463</b><i>a</i>, and passes design instance data structure <b>465</b> to instrumented design instance data structure <b>465</b><i>a. </i>

[0154] If however, a target entity is loaded from design entity HDL files <b>340</b>, rather than from design entity proto files <b>345</b>, instrumentation load tool <b>464</b> must alter its design proto data structure <b>463</b> and its design instance data structure <b>465</b> to instantiate an associated instrumentation entity. An instrumented design proto data structure <b>463</b><i>a </i>and instrumented design instance data structure <b>465</b><i>a </i>are thereby produced. In addition, instrumentation load tool <b>464</b> creates an instrumentation instance data structure <b>467</b> for each instrumentation entity associated with the current design entity.

[0155] The design entity proto data structures <b>463</b> that are altered by instrumentation load tool <b>464</b> are saved to disk <b>33</b> of computer system <b>10</b> as design entity proto files <b>344</b>. Design entity proto files <b>344</b>, 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 <b>464</b> on subsequent recompilations unless an alteration is made to a design entity or an associated instrumentation entity.

[0156] In order for HDL compiler <b>462</b> to determine if alterations were made to either a target design entity or the target design entity'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 <b>462</b> can determine, by inspection of the BOM for a given design entity, whether to recompile the design entity and the design entity's associated instrumentation entities or load these structures from proto files <b>345</b> and <b>461</b>.

[0157] Finally, instrumentation load tool <b>464</b> creates a unique proto and instance data structure for instrumentation logic block <b>420</b> and connects the fail, harvest, and count event signals from each instrumentation entity instantiation to instrumentation logic block <b>420</b>. Model build tool <b>446</b> processes in-memory proto and instance data structures <b>463</b><i>a</i>, <b>465</b><i>a</i>, <b>467</b>, <b>466</b> to produce instrumented simulation executable model <b>480</b>

[0158] In HDL compiler <b>462</b>, 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 <b>462</b> is shown below: <tables id="TABLE-US-00002" num="2"><table frame="none" colsep="0" rowsep="0"><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="154PT" align="left" /><colspec colname="2" colwidth="49PT" align="center" /><thead><row><entry /><entry /></row><row><entry /><entry namest="OFFSET" nameend="2" align="center" rowsep="1" /></row></thead><tbody valign="top"><row><entry /><entry>process_HDL_file2(file,design_flag)</entry><entry> 5</entry></row><row><entry /><entry>{</entry><entry> 10</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="140PT" align="left" /><colspec colname="2" colwidth="49PT" align="center" /><tbody valign="top"><row><entry /><entry>if (NOT proto_loaded(file)) {</entry><entry> 15</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="126PT" align="left" /><colspec colname="2" colwidth="49PT" align="center" /><tbody valign="top"><row><entry /><entry>if (exists_proto_file(file)</entry><entry> 20</entry></row><row><entry /><entry>AND check_bom(file)) {</entry></row><row><entry /><entry>load_proto(file);</entry><entry> 25</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="140PT" align="left" /><colspec colname="2" colwidth="49PT" align="center" /><tbody valign="top"><row><entry /><entry>}else {</entry><entry> 30</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="126PT" align="left" /><colspec colname="2" colwidth="49PT" align="center" /><tbody valign="top"><row><entry /><entry>parse_HDL_file(file)</entry><entry> 35</entry></row><row><entry /><entry>for (all instances in file) {</entry><entry> 40</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="112PT" align="left" /><colspec colname="2" colwidth="49PT" align="center" /><tbody valign="top"><row><entry /><entry>process_HDL_file2(instance,</entry><entry> 45</entry></row><row><entry /><entry>design_flag);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="126PT" align="left" /><colspec colname="2" colwidth="49PT" align="center" /><tbody valign="top"><row><entry /><entry>}</entry><entry> 50</entry></row><row><entry /><entry>if (design_flag=TRUE) {</entry><entry> 55</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="2"><colspec colname="OFFSET" colwidth="70PT" align="left" /><colspec colname="1" colwidth="147PT" align="left" /><tbody valign="top"><row><entry /><entry>for (all instrumentation</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="112PT" align="left" /><colspec colname="2" colwidth="49PT" align="center" /><tbody valign="top"><row><entry /><entry>instances in file) {</entry><entry> 60</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="70PT" align="left" /><colspec colname="1" colwidth="98PT" align="left" /><colspec colname="2" colwidth="49PT" align="center" /><tbody valign="top"><row><entry /><entry>process_HDL_file2(in-</entry><entry> 65</entry></row><row><entry /><entry>stance, FALSE);</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="56PT" align="left" /><colspec colname="1" colwidth="112PT" align="left" /><colspec colname="2" colwidth="49PT" align="center" /><tbody valign="top"><row><entry /><entry>}</entry><entry> 70</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="42PT" align="left" /><colspec colname="1" colwidth="126PT" align="left" /><colspec colname="2" colwidth="49PT" align="center" /><tbody valign="top"><row><entry /><entry>}</entry><entry> 75</entry></row><row><entry /><entry>create_proto(file);</entry><entry> 80</entry></row><row><entry /><entry>write_proto_file(file);</entry><entry> 90</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="140PT" align="left" /><colspec colname="2" colwidth="49PT" align="center" /><tbody valign="top"><row><entry /><entry>}</entry><entry> 95</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="154PT" align="left" /><colspec colname="2" colwidth="49PT" align="center" /><tbody valign="top"><row><entry /><entry>}</entry><entry>100</entry></row><row><entry /><entry>if (design_flag = TRUE) {</entry><entry>105</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="28PT" align="left" /><colspec colname="1" colwidth="147PT" align="left" /><colspec colname="2" colwidth="42PT" align="center" /><tbody valign="top"><row><entry /><entry>create_instance(file);</entry><entry>110</entry></row></tbody></tgroup><tgroup align="left" colsep="0" rowsep="0" cols="3"><colspec colname="OFFSET" colwidth="14PT" align="left" /><colspec colname="1" colwidth="154PT" align="left" /><colspec colname="2" colwidth="49PT" align="center" /><tbody valign="top"><row><entry /><entry>}</entry><entry>115</entry></row><row><entry /><entry>}</entry><entry>120</entry></row><row><entry /><entry namest="OFFSET" nameend="2" align="center" rowsep="1" /></row></tbody></tgroup></table></tables>

[0159] Algorithm process_HDL_file2( ) is an augmentation to process_HDL_file( ) of HDL compiler <b>342</b> 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_file2( ) (line 5) first checks, by means of routine proto_loaded( ) (line 15), if the proto for the current entity is already present in memory <b>44</b>. If so, processing passes to line 105. Otherwise, control is passed to line 20 and 25 where disk <b>33</b> of computer system <b>10</b> 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 <b>10</b> by routine load_proto( ) (line 25) creating proto data structures, as necessary, in memory <b>44</b> for the current entity and the current entity's descendants including instrumentation entities.

[0160] 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_file2( ) (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_file2( ) (line 5) to process any instrumentation entities instantiated by means of instrumentation instantiation comments. It should be noted that algorithm process_HDL_file2( ) (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 <b>44</b> 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 <b>33</b> of computer system <b>10</b>.

[0161] 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's descendants. If the current entity is an instrumentation entity, routine create_instance( ) (line 110) is not called. Instrumentation load tool <b>464</b> is utilized to create the in-memory instance data structures for instrumentation entities.

[0162] It will be apparent to those skilled in the art that HDL compiler <b>462</b> 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 <b>464</b> can be merged into HDL compiler <b>462</b>.

[0163] With reference now to FIG. 4E wherein is shown a depiction of memory <b>44</b> at the completion of compilation of simulation model <b>329</b> with instrumentation entities FXUCHK and FPUCHK. Memory <b>44</b> contains proto data structures <b>481</b>, one for each of the design and instrumentation entities referred to in simulation model <b>329</b>. In addition, design and instrumentation instances in simulation model <b>329</b> are represented by instance data structures <b>482</b>. 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 <b>329</b>.

[0164] With reference now to FIG. 5A, wherein is depicted failure flags <b>424</b> of instrumentation logic block <b>420</b> in greater detail. Failure flags <b>424</b> consist of registers <b>500</b><i>a</i>-<b>500</b><i>n </i>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 <b>502</b> will be discussed. The operation of all failure flags is similar.

[0165] Register <b>500</b><i>a </i>holds a value that represents whether a failure event <b>502</b> has occurred or not. Register <b>500</b><i>a </i>is initially set to a value of ‘0’ by the simulation run-time environment at the beginning of a simulation run. When failure event <b>502</b>, if enabled at register <b>507</b><i>a</i>, occurs, register <b>500</b><i>a </i>is set to a value of a logical ‘1’, thereby indicating the occurrence of a failure event. Register <b>500</b><i>a </i>is driven by logical OR gate <b>501</b>. Logical OR gate <b>501</b> performs a logical OR of the output of register <b>500</b><i>a </i>and a qualified failure signal <b>503</b> to create the next cycle value for register <b>500</b><i>a</i>. In this manner, once register <b>500</b><i>a </i>is set to a logical ‘1’ by the occurrence of an enabled failure event, register <b>500</b><i>a </i>maintains the value of a logical ‘1’ until reset by the simulation runtime environment. Likewise, register <b>500</b><i>a </i>maintains a value of ‘0’ from the beginning of the simulation run until the occurrence of the failure event, if enabled.

[0166] Qualified failure signal <b>503</b> is driven by logical AND gate <b>505</b>. Logical AND gate <b>505</b> produces, on qualified failure signal <b>503</b>, the logical AND of failure signal <b>506</b> and the logical NOT of register <b>507</b><i>a</i>. Register <b>507</b><i>a </i>serves as an enabling control for qualified failure signal <b>503</b>. If register <b>507</b><i>a </i>contains a value of ‘0’, logical AND gate <b>505</b> will pass failure event signal <b>506</b> unaltered to qualified failure signal <b>503</b>. In this manner, the monitoring of the failure event is enabled. Registers <b>507</b><i>a</i>-<b>507</b><i>n </i>are set, by default, to a value of ‘0’. However, if register <b>507</b><i>a </i>contains a value of a logical ‘1’, qualified failure signal <b>503</b> will remain at a value of ‘0’ irrespective of the value of failure event signal <b>506</b>, thereby disabling the monitoring of failure event <b>502</b>. In this manner, register <b>508</b>, consisting of registers <b>507</b><i>a</i>-<b>507</b><i>n</i>, can mask the occurrence of any subset of failure events in the overall simulation model from registers <b>500</b><i>a</i>-<b>500</b><i>n. </i>

[0167] 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 <b>507</b><i>a</i>-<b>507</b><i>n </i>within register <b>508</b> to disable the monitoring of a particular failure event for every instance of the instrumentation entity within the overall simulation model. Instrumentation load tool <b>464</b> and model build tool <b>446</b> encode sufficient information within instrumented simulation executable model <b>480</b> to determine which failure bits within register <b>508</b> correspond to which instrumentation entities.

[0168] 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.

[0169] Logical OR gate <b>512</b> is utilized to produce a signal, <b>511</b>, 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.

[0170] 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.

[0171] In order to execute simulation model <b>520</b> on a hardware simulator, a termination signal <b>513</b>, is typically utilized as a means to avoid having to poll the model after each cycle. Typically, a hardware simulator will cycle simulation model <b>520</b> until signal <b>513</b> is asserted to a logical ‘1’. The assertion of termination signal <b>513</b> to a logical ‘1’ indicates that a simulation run has finished. Without termination signal <b>513</b>, it would be necessary to directly poll facilities within simulation model <b>520</b> to determine when a simulation run is completed.

[0172] To efficiently locate and diagnose problems in simulation model <b>520</b>, it is advantageous to allow a simulation run to be stopped immediately whenever a failure event occurs during simulation of simulation model <b>520</b> (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 <b>513</b> 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 <b>515</b> will automatically be included within the simulation model. Logical OR gate <b>515</b> produces the logical OR of signals <b>511</b> and <b>513</b> on signal <b>516</b>. Signal <b>516</b> is therefore asserted to a logical ‘1’ whenever the simulation run has completed (signal <b>513</b> high) or a failure event has occurred (signal <b>511</b> high). Consequently, by executing simulation model <b>520</b> in a hardware simulator until signal <b>516</b> is asserted to a value of a logical ‘1’, the instrumentation for simulation model <b>520</b> 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 <b>513</b> is not present, logical OR gate <b>515</b> is not included in the model and signal <b>511</b> is directly connected to signal <b>516</b>. The name of signal <b>516</b> is fixed to a particular name by convention.

[0173] 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.

[0174] 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”.

[0175] 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.

[0176] 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.

[0177] With reference now to FIG. 6A, there is depicted a gate level representation of exemplary logic for one counter of counters <b>421</b> within instrumentation logic block <b>420</b> depicted in FIG. 4B. Each counter of <b>421</b> is represented by a multi-bit simulator latch <b>600</b>. Simulator latch <b>600</b> is initialized by the simulation runtime environment to a value of zero at the beginning of a simulation run. Simulator latch <b>600</b> is updated every simulator cycle and is driven by multiplexor <b>601</b>. Multiplexor <b>601</b>, controlled by selector signal <b>602</b>, selects between signal <b>613</b>, the current value of simulator latch <b>600</b>, and signal <b>605</b>, the current value of simulator latch <b>600</b> incremented by 1 by incrementor <b>604</b>, to serve as the next cycle value for simulator latch <b>600</b>. By selecting signal <b>605</b>, multiplexor <b>601</b> causes the counter value within simulator latch <b>600</b> to be incremented when a count event occurs. It should be noted, however, that simulator latch <b>600</b> 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 <b>606</b> and simulator latch <b>607</b> serve to disable the monitoring of count event signal <b>609</b> in a manner similar to that described above for the disabling of failure events. Signal <b>608</b> is count event signal <b>609</b> further qualified by signal <b>610</b> by means of logical AND gate <b>611</b>.

[0178] Signal <b>610</b> insures that simulator latch <b>600</b> will be incremented, if count event signal <b>609</b> 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 <b>421</b> correspond directly to the number of design cycles the event occurred in and not the number of simulator cycles the event occurred in. For example if an event occurs in two design cycles where design cycle require four simulators cycles, it is preferable to have the event counter 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.

[0179] 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 <b>421</b> 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.

[0180] 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.

[0181] Each count event signal has an associated qualifying signal as specified by counter declaration comments <b>455</b> 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 <b>600</b>, qualifying signal <b>612</b>, is depicted as a high-active qualifier signal. Qualifying signal <b>612</b> is processed by simulator latch <b>613</b> and logical AND gate <b>614</b>, to produce signal <b>610</b> which is active high for one and only one simulator cycle within the design cycle delineated by qualifying signal <b>612</b>.

[0182] Turning now to FIG. 6B there is illustrated a simplified timing diagram that demonstrates operation of simulator latch <b>613</b> and logical AND gate <b>614</b> assuming clocking qualifying signal <b>612</b> is a high active clocking signal of fifty percent duty cycle for a design cycle that occurs over a 10-simulation cycle period. Signal <b>615</b>, the output of simulator latch <b>613</b>, is qualifying signal <b>612</b> delayed by one simulator cycle. Signal <b>615</b> is inverted and logically ANDed with qualifying signal <b>612</b> to produce signal <b>610</b>, 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 <b>612</b> would be inverted and signal <b>615</b> would be uninverted by logical AND gate <b>614</b>. This would produce a single simulator cycle active high pulse during the first simulator cycle of the design cycle. Qualifying signal <b>610</b>, by qualifying count event signal <b>609</b> by means of logical AND gate <b>611</b>, insures that counter <b>600</b> is incremented only once per design cycle irrespective of the number of simulator cycles utilized to represent a design cycle.

[0183] 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 <b>613</b> and logical gates <b>614</b> and <b>611</b> are unnecessary. Rather, counter latch <b>600</b> is replaced by a positive or negative edge triggered simulator latch based on the polarity of qualifying signal <b>612</b>. Qualifying signal <b>612</b> is connected directly to simulator latch <b>600</b> and directly controls the updates of counter latch <b>600</b> insuring that the latch is updated only once per design cycle.

[0184] Returning to FIG. 6A, incrementor <b>604</b> represents but one possible mechanism that may be utilized to implement the next logic state for a given counter within the present invention. As depicted in FIG. 6A, incrementor <b>604</b> ensures that counters <b>421</b> within a model are cycled through a series of values whose binary patterns correspond to the customary representation of non-negative integers. In one embodiment of the present invention, incrementor <b>604</b> is comprised of an adder that increments the current value of counter <b>600</b> by a unit value each time signal <b>605</b> is selected by selector signal <b>602</b>. This exemplary implementation provides for convenience of decoding the value of counter <b>600</b> at the termination of a simulation run, but does so at a cost in overhead that is not acceptable in many simulators.

[0185] For software simulators, one of two basic approaches may be utilized to model an incremetor, such as incrementor <b>604</b>. In the first approach, the incrementor is modeled directly by an ADD or INCREMENT instruction in the simulation execution model. When incrementors are modeled directly as a single instruction within the simulation execution model, the use of incrementor <b>604</b> provides for efficient counters within a simulation execution model.

[0186] However, many software simulators and virtually all hardware simulators model incrementor functions as a set of gates that are replicated essentially without change at each bit position of the counter. Within a software simulator, these gates must be translated into a sequence of instructions. In a hardware simulator, these gates are explicitly replicated for each counter as individual gates. Due to implementation or structural limitations, many software simulators are incapable of modeling an incrementor in any other manner than as a set of gates. Clearly, for these software simulators that must model incrementors as a number of gates and therefore as a sequence of instructions, a performance loss will result over those software simulators that model incrementors as a single increment or add instruction. Likewise, for hardware simulators, the number of gates required for each adder, which must be modeled directly by gates within the hardware simulator, can prove to be a significant burden.

[0187] The method and system of the present invention alleviate these difficulties by implementing a linear feedback shift register as the counting means within counting instrumentation. As explained below, appropriate configuration and utilization of such a liner feedback shift register results in an efficient method of incrementing a counter that avoids the overhead associated with incrementor <b>604</b>.

[0188] With reference now to FIG. 7, there is depicted a linear feedback shift register (LFSR) counter <b>700</b> consisting of a shift register <b>704</b> and “exclusive NOR” (XNOR) gate <b>706</b>. Various methods of constructing LFSRs are known to those skilled in the art. As illustrated in FIG. 7, LFSR counter <b>700</b> includes a modified shift register <b>704</b> that may replace register <b>600</b> and incrementor <b>604</b> of FIG. 6A. LFSR counter <b>700</b> also includes multiplexor <b>601</b> (replicated bit-by-bit within LFSR <b>704</b>) which provide feedback paths <b>616</b>. Feedback path <b>616</b> provides a means for shift register <b>704</b> to maintain its current value during those simulator cycles in which no count pulse trigger (signal <b>602</b>) is received. For hardware and software design simulators in which, for logistical or other reasons, incrementation of counters must be accomplished utilizing a set of gates for each counter, shift register <b>704</b> replaces register <b>600</b> within the counter logic depicted in FIG. 6A. The need for incrementor <b>604</b> is thus eliminated and is replaced by XNOR gate <b>706</b>. In this manner, register <b>600</b> and incrementor <b>604</b> are replaced utilizing a more efficient logic structure having substantially reduced overhead. Counters <b>421</b> of FIG. 4B, will therefore consist of LFSR-based configurations such as LFSR counter <b>700</b> whose values can be decoded at the end of a simulation run to reveal their corresponding integral values.

[0189] Shift register <b>704</b> can be of any desired length. In a preferred embodiment, shift register <b>704</b> is a 22 bit register, although larger or smaller registers may be employed. Shift register <b>704</b> consists of latches <b>718</b> arranged in a serial fashion such that a given latch's output is utilized as input to the next latch <b>718</b> within shift register <b>704</b>. In addition, a select subset of latches <b>718</b> within shift register <b>704</b> have their outputs sourced to XNOR gate <b>706</b>. XNOR gate <b>706</b> is utilized to provide an input for the first latch within shift register <b>704</b>.

[0190] The LFSR is a logic structure that, when properly configured, will sequence through all possible bit patterns with the exception of the all-ones pattern (it is possible to construct LFSRs which exclude the all-zeros pattern or LFSRs that cycle through all possible bit patterns). For example, in a 22 bit LFSR, bits <b>1</b> and <b>22</b> may be selected for inputs to XNOR gate <b>706</b> to provide a sequence of bit patterns in shift register <b>704</b> which traverses every possible permutation with the exception of the all-ones pattern. Shift register <b>704</b> must be loaded with an initial value that is not the all ones pattern. This may be accomplished automatically by initializing all latches to a binary zero value within the simulator, or by utilizing the control program that drives the simulator to explicitly set these latches to binary zeros.

[0191] After initialization, the numeric pattern held by bit positions <b>718</b> of shift register <b>704</b> will cycle through a specific and predictable pattern in a repeating fashion. That is to say, for any given bit pattern present in shift register <b>704</b>, there is a specific, unique pattern the shift register will subsequently assume upon being shifted and therefore, the sequence of patterns through which the shift register cycles is fixed and repeats in a predictable manner. Due to these properties, LFSR counter <b>700</b> can be utilized as a counting means within for the instrumentation detection means previously described. By assigning the value of “zero” to a pre-selected starting value (say the all zeros pattern for shift register <b>704</b>), the value of “one” to the next bit pattern formed by shifting the LFSR, and so on, the LFSR can serve as a counter. To be useful as a counter, the bit patterns within shift register <b>704</b> must be converted back to their corresponding integer values. This is easily accomplished for LFSRs with a small number of bits (less than 25 bits) by means of a lookup table consisting of an array of values, where the index of the array corresponds to the LFSR bit pattern value and the entry in the array is the decoded integer value for the LFSR. For LFSRs with a larger number of bits, software decoding techniques can be utilized to decode the LFSR value by simulating the operation of the LFSR.

[0192] As illustrated in FIG. 7, the logic necessary to implement LFSR counter <b>700</b> consists of the single XNOR gate <b>706</b> with two feedback inputs. While the number of required feedback gates and inputs thereto may vary in proportion to different possible lengths of an LFSR, in general, for typical LFSRs (less than 200 bits), only one XNOR gate with a relatively small number of inputs (less than 5 bits) is required. This is in marked contrast to the several logic gates per bit required for conventional incrementors. Therefore, significant savings in counter overhead can be achieved by substituting LFSR-based counter <b>700</b> for the incrementor structure depicted in FIG. 6A, especially for simulators that model incrementors utilizing logic gate based representations.

[0193] While the above described system and method provides a practical means of instrumenting simulation models, in certain circumstances additional techniques maybe used in order to enhance the ease with which a user may instrument a simulation model. In design, it often occurs that there are common design or instrumentation logic constructs that are often repeated and possess a regular structure.

[0194] By utilizing knowledge of the regular structure of these design and instrumentation logic constructs, it is often possible to define a syntax that describes the instrumentation logic with considerably greater efficiency than would be possible utilizing a conventional HDL construct. By utilizing this syntax as an unconventional HDL comment within a design VHDL file, it is possible to create instrumentation entities with considerably greater ease and efficiency.

[0195] Such comments within a design entity will be referred to hereinbelow as an embedded instrumentation entity comment while the instrumentation logic created by such a comment will be referred to as an embedded instrumentation entity.

[0196] A common logic design construct is the so-called “finite state machine”. A finite state machine typically consists of a number of storage elements to maintain the “state” of the state machine and combinatorial logic that produces the next state of the state machine and its outputs. These constructs occur with great frequency in typical logic designs and it is advantageous to be able to efficiently instrument these constructs.

[0197] A typical set of count and failure events for a finite state machine includes counting the number of times a state machine cycles from a given current state to some next state, counting the number of functional cycles the state machine spends in each state, ensuring that the state machine does not enter an illegal state, and ensuring that the state machine does not proceed from a current given state to an illegal next state. This list of events is but one of many possible sets of events that can be used to characterize a finite state machine and is used in an illustrative manner only.

[0198] With reference now to FIG. 8A there is depicted a representation of an exemplary state machine <b>800</b>. Exemplary state machine <b>800</b> consists of five states, labeled S0, S1, S2, S3, and S4 respectively, and nine legal state transitions between these states. In what follows, it is assumed that state machine <b>800</b> consists of three latches and a set of combinatorial logic to produce the next state function. It is further assumed that the states are encoded into the three latches following the usual and customary encoding for integers. That is to say, state S0 gets an encoding of 000_bin, state S1 gets an encoding of 001_bin, state S2 gets and encoding of 010_bin, and so on.

[0199] With reference now to FIG. 8B there is shown an exemplary design entity <b>850</b> referred to as entity FSM with instance name FSM, which contains one instance of state machine <b>800</b>. Furthermore, a signal output <b>801</b>, “fsm_state(0 to 2)” contains a three bit signal directly connected to the outputs of the three storage elements comprising the state elements of state machine <b>800</b>. A signal input <b>802</b>, fsm_clock, applies a clocking signal that controls the storage elements for state machine <b>800</b>.

[0200] In order to instrument state machine <b>800</b>, it would conventionally be necessary to create an instrumentation entity VHDL file containing the logic necessary to detect the desired state machine events and pass them through to count and fail events. Such an instrumentation entity file with appropriate instrumentation entity descriptor comments would typically require substantially more lines of code than the HDL description of the state machine itself. Such a circumstance is undesirable. However, in the case of a regular logic structure such as a finite state machine, it is possible to define a brief syntax that characterizes the finite state machine without resorting to a separate instrumentation VHDL entity.

[0201] With reference now to FIG. 8C there is illustrated an exemplary HDL file <b>860</b> for generating design entity <b>850</b> with an embedded instrumentation entity for monitoring the behavior of FSM <b>800</b>. Specifically, an embedded instrumentation entity comment <b>852</b> is illustrated. As depicted in FIG. 8C, embedded instrumentation entity comment <b>852</b> comprises a number of distinct sections including: a prologue and embedded instrumentation name declaration <b>853</b>, a state machine clock declaration <b>859</b>, a state element declaration <b>854</b>, a state naming declaration <b>855</b>, a state element encoding declaration <b>856</b>, a state machine arc declaration <b>857</b>, and an epilogue <b>858</b>.

[0202] Prologue and embedded instrumentation entity name declaration comment <b>853</b> serves to declare a name that is associated with this embedded instrumentation entity. This comment line also serves to delineate the beginning of an embedded instrumentation entity comment sequence.

[0203] As further depicted in FIG. 8C, declaration comment <b>853</b> assumes a non-conventional syntax of the form: “--!! Embedded TYPE: name”, wherein “--!! Embedded” serves to declare an embedded instrumentation entity, “TYPE” declares the type of the embedded instrumentation entity—FSM in this case, and “name” is the name associated with this embedded instrumentation entity.

[0204] State machine clock declaration comment <b>859</b> is utilized to define a signal that is the clocking control for the finite state machine.

[0205] State element declaration comment <b>854</b> is utilized to specify the state-machine state storage elements. This comment declares the storage elements or signal names that constitute the state-machine state. In state machine <b>800</b>, the signals fsm_state(0 to 2) constitute the state machine state information.

[0206] State naming declaration comment <b>855</b> is utilized to declare labels to associate with various states of the given state machine. These labels are utilized in state machine arc declaration comment <b>857</b> when defining the legal state transitions within the given state machine.

[0207] State element encoding declaration comment <b>856</b> is utilized to define a correspondence between the state machine labels defined by state naming declaration comment <b>855</b> and the facilities declared by state element declaration comment <b>854</b>. In the example shown, the labels of comment <b>855</b> are associated by position with the encodings given in comment <b>856</b> (i.e., the state labeled “S0” has the encoding 000_bin, the state labeled “S1” has the encoding 001_bin, etc.).

[0208] State-machine arc declaration comment <b>857</b> defines the legal state transitions within the state machine. The various transitions of the state machine are given by terms of the form “X=&gt;Y” where X and Y are state machine state labels given by comment <b>855</b> and X represents a previous state machine state and Y a subsequent state machine state.

[0209] Epilogue comment <b>858</b> serves to close the embedded instrumentation entity comment. The specific syntax and nature of the comments between the prologue and embedded instrumentation name declaration and the epilogue will vary with the specific needs of the type of embedded instrumentation entity being declared.

[0210] Embedded instrumentation entity comment <b>852</b> is inserted within the VHDL file of the design entity that contains the finite state machine in question. The embedding of instrumentation for finite state machine <b>800</b> is made possible by the non-conventional comment syntax illustrated in FIG. 8C and is substantially more concise than a conventional HDL instrumentation entity suitable for accomplishing the same function.

[0211] Utilizing such embedded non-conventional comments, the system of the present invention creates an instrumentation entity, as described below, for instrumenting the state machine without the need to resort to creating a separate HDL file instrumentation entity.

[0212] To support compilation and creation of embedded instrumentation entities, the previously described compilation process of FIG. 4D is enhanced as described herein. First, HDL compiler <b>462</b> is altered to recognize the presence of embedded instrumentation entity comments. If, during compilation of a design HDL file, and subject to the constraints described above for incremental compilation, HDL compiler <b>462</b> detects one or more embedded instrumentation entity comments within the source code file, HDL compiler <b>462</b> places a special marker into design entity proto data structure <b>463</b>.

[0213] When instrumentation load tool <b>464</b> is passed control, proto data structures <b>463</b> are searched in order to locate the special marker placed by HDL compiler <b>462</b> indicating embedded instrumentation entity comments. Such protos represent the design HDL files with embedded instrumentation entities that have been re-compiled in the current compilation cycle.

[0214] When instrumentation load tool <b>464</b> locates a proto data structure <b>463</b> with the special marker, the corresponding VHDL source code file for the design entity is opened and parsed to locate the one or more embedded instrumentation entity comments. For each of these comments, instrumentation load tool <b>464</b> creates a specially named proto data structure <b>463</b><i>a</i>, and further generates a corresponding instance data structure <b>465</b><i>a </i>that is instantiated within the design entity. In addition, instrumentation load tool <b>464</b> removes the special marker inserted by HDL compiler <b>462</b> to prevent unnecessary re-instrumentation of the design proto on subsequent re-compiles.

[0215] Within these created embedded instrumentation entity protos, instrumentation load tool <b>464</b> directly creates the necessary instrumentation logic required by the embedded instrumentation entity without the need for a VHDL file to specify this instrumentation and connects this logic to instrumentation logic block <b>420</b> of FIG. 4D. The updated design proto along with the embedded instrumentation entity proto and instance data structure are saved to disk and serve as inputs to subsequent compiles, removing the need to produce embedded instrumentation entities on subsequent recompiles.

[0216] With reference now to FIG. 9, design entity <b>850</b> is shown instrumented with embedded instrumentation entity <b>900</b>. Embedded instrumentation entity <b>900</b> is created as a proto instantiated within design entity <b>850</b> wherein the embedded non-conventional instrumentation entity comment occurs. The embedded instrumentation entity thus may be replicated automatically within an overall design wherever the specific design entity is instantiated.

[0217] Embedded instrumentation entity <b>900</b> is named in a unique manner based on the name associated with the embedded instrumentation entity by the prologue and embedded instrumentation name declaration comment. This name is pre-pended with a special character (shown as a “$” in FIG. 9) that is not a recognized naming convention for the platform HDL. In this manner, the names of the embedded instrumentation entities cannot conflict with the names of any other design or standard instrumentation entities.

[0218] Furthermore, the names associated with the various events defined by the embedded instrumentation entity (the “varname” for the count events, for example) are also derived in a fixed manner from the name associated with the embedded instrumentation entity. The user is required to ensure that the names of embedded instrumentation entity events do not conflict with the names of standard instrumentation entity events and further than the names of the embedded instrumentation entities within a given design do not themselves conflict.

[0219] It should also be noted that if a design entity contains more than one embedded instrumentation entity, the embedding process described with reference to FIG. 8B and FIG. 9 is simply repeated for each such instrumentation entity. In addition, since the protos for the embedded instrumentation entities are created at the same time as the design protos itself, no changes to the BOM mechanism used for incremental compiles are required. The protos for the embedded instrumentation entities can be considered, for purposes of incremental compilations, to be mere extensions to the design proto itself.

[0220] The present invention discloses a method and system for naming events within a simulation model that prevents name collisions be twe en events in different instrumentation entities, allows for the arbitrary re-use of components of a model in models of arbitrarily increasing size, and furthermore allows for processing designated events in a hierarchical or non-hierarchical manner.

[0221] When all instances of an event are considered as a whole without regard to specific instances, the event is considered in a “non-hierarchical” sense. Likewise, when an event is considered with regard to each and every instance, it is considered in a “hierarchical” sense. When considering count events, for example, it is often convenient to track the number of times a particular count event occurred in the aggregate without concern to exactly how many times the count event occurred in each particular instance within a simulation model.

[0222] Each type of event: count, fail, and harvest, is given a separate event namespace by construction. Each event class is therefore an independent group preventing naming collisions between the event types. The data structure of the present invention is independently applied to each of the different event types to ensure correctness within each event class.

[0223] In the embodiments illustrated in FIGS. 10A, 10B, <b>10</b>C, and <b>10</b>D, the system and method of the present invention are described with respect to count events. One skilled in the art will appreciate and understand the extensions necessary to apply the same techniques to other event classes such as failures or harvests.

[0224] With reference to FIG. 10A, there is depicted a block diagram representation of simulation model <b>1000</b> containing a number of design and instrumentation entities. As illustrated in FIG. 1A, simulation model <b>1000</b> includes two instances of a design entity X, with instance names X1 and X2 respectively.

[0225] Within each of design entity instances X1 and X2 is instantiated an instance of an instrumentation entity B3, <b>1012</b><i>a </i>and <b>1012</b><i>b</i>. Design entity instances X1 and X2 further comprise instances, <b>1014</b><i>a </i>and <b>1014</b><i>b</i>, respectively, of design entity Z which further contains instances, <b>1016</b><i>a </i>and <b>1016</b><i>b</i>, of instrumentation entity B1 and instances, <b>1018</b><i>a </i>and <b>1018</b><i>b</i>, of instrumentation entity B2.

[0226] Finally, simulation model <b>1000</b> includes an instance of design entity Y, with instance name Y, containing an instance of instrumentation entity B4 <b>1022</b>. Design entity instance Y contains an instance, <b>1024</b>, of design entity Z with further instances, <b>1016</b><i>c </i>and <b>1018</b><i>c</i>, of instrumentation entities B1 and B2 respectively.

[0227] In what follows the methods of the present invention for uniquely naming events will be considered in the context of exemplary model <b>1000</b>. It will be assumed in the following description that each instrumentation entity (B1, B2, B3, and B4) has declared a single count event with event name “count1”.

[0228] In accordance with the method and system of the present invention, the user must uniquely name each type of event (count, fail, or harvest) within a specific instrumentation entity, i.e., the user cannot declare any two events of the same type within the same instrumentation entity with the same event name. Such a constraint does not conflict with the stated goals of the present invention in that a given instrumentation entity is usually created by a specific person at a specific point in time, and maintaining unique names within such a limited circumstance presents only a moderate burden to the user. The data structure disclosed herein does, however, prevent all name collisions between events in different instrumentation entities, and allows for processing the events in a hierarchical and/or non-hierarchical manner.

[0229] As previously explained, an HDL naming convention must uniquely identify all the entities within a given design. This constraint is inherent to HDLs and applies to design entities as well as instrumentation entities. In accordance with conventional VHDL entity naming constructs, it is technically possible for two design entities to share the same entity name, entity_name. However, such identically named entities must be encapsulated within a VHDL library from which a valid VHDL model may be constructed. In such a circumstance, entity_name, as it is utilized herein, is equivalent to the VHDL library name concatenated by a period (“.”) to the entity name as declared in the entity declaration.

[0230] Pre-pending a distinct VHDL library name to the entity name disambiguates entities sharing the same entity name. Most HDLs include a mechanism such as this for uniquely naming each design entity. Design entities must be unambiguously named in order to determine which particular entity is called for in any given instance in a simulation model. The present invention employs the prevailing naming mechanism of the native HDL to assign unique entity names for design entities throughout a given model and leverages the uniqueness property of entity names and the uniqueness of each instance's instantiation identifier to create an “extended event identifier” for each event within the simulation model.

[0231] With reference to FIG. 10B, there is illustrated a representation of the fields in an extended event identifier data structure, alternatively referred to herein as an “event list”, in accordance with one embodiment of the present invention. The extended event identifier begins with instantiation identifier field <b>1030</b>. This field, as described hereinbefore, consists of the instance identifiers, proceeding from the top level entity to the direct ancestor of the given instance within the simulation model separated by periods (“.”). This string is unique for each and every instance of the event within the model. The extended event identifier further includes an instrumentation entity field <b>1032</b>, a design entity field <b>1034</b>, and an eventname field <b>1036</b>.

[0232] Instrumentation entity field <b>1032</b> contains the name of the instrumentation entity (or the name assigned to an embedded instrumentation entity) that generates the simulation event. Design entity field <b>1034</b> contains the entity name of the design entity in which the event occurs. Eventname field <b>1036</b> is the name given to the event in the instrumentation entity description comments of an instrumentation entity or the event name assigned to an event within an embedded instrumentation entity. These four namespace fields comprise a unique identifier for each event within a simulation model that allows for the re-use of components within other models without risk of name collisions and the consideration of events in a hierarchical or non-hierarchical sense.

[0233] With reference now to FIG. 10C, there is shown a list of extended event identifiers for model <b>1000</b>. Event identifiers <b>1040</b>, <b>1041</b>, <b>1042</b>, <b>1043</b>, <b>1044</b>, <b>1045</b>, <b>1046</b>, <b>1047</b>, and <b>1048</b> are declared within simulation model <b>1000</b> to designate count events having eventname “count1”. The extended event identification procedure of the present invention will be described in the context of these extended event identifiers.

[0234] The uniqueness of the names in design entity name field <b>1034</b> is a primary distinguishing factor between events. By including the design entity name in the extended event identifier, each design entity is, in effect, given a unique namespace for the events associated with that design entity, i.e., events within a given design entity cannot have name collisions with events associated with other design entities.

[0235] It is still possible however, to have name collisions between events defined by different instrumentation entities that are incorporated within a single design entity. Events <b>1041</b> and <b>1042</b>, for example, if identified solely by the design entity name, have a name collision. Both are events with eventname “count1” within design entity Z, and if labeled as such, are indistinguishable. In order to alleviate a naming collision between events <b>1041</b> and <b>1042</b>, the present invention employs instrumentation entity field <b>1032</b>. By referencing the design entity and instrumentation entity names, both of which are unique with respect to themselves and each other, a unique event namespace is created for each instrumentation entity associated with any given design entity. For example, event identifier <b>1041</b> and <b>1042</b> would be in conflict (both named Z.count1), unless the respective instrumentation entity names are included within the extended event identifier to produce names B1.Z.count1 and B2.Z.count2 for these events.

[0236] It should be noted that it is possible to uniquely name each event by using instrumentation entity name field <b>1032</b> alone. Due to the uniqueness property of instrumentation entity names, event names that are only named by the instrumentation entity name and the event name field will be necessarily unique.

[0237] However, such a naming scheme is insufficient for associating events with a given design entity. In practice, it is desirable to associate events with the design entity in which they occur rather than associating them with the potentially numerous instrumentation entities that are utilized to track them. Moreover, referencing the appropriate design entity within the eventname allows all the events associated with a given design entity to be centrally referenced without the need to ascertain the names of all the instrumentation entities associated with the given design entity. The data structure of the present invention utilizes both the instrumentation entity and design entity names in naming events for ease of reference at the cost of moderate uniqueness redundancy in the event names.

[0238] In an alternative embodiment of the present invention, the instrumentation entity name is not included within the extended event identifier. Referring to FIG. 10D, such an alternative extended event identification data structure is depicted. As shown in FIG. 10D, events are named by instantiation identifier field <b>1030</b>, design entity name field <b>1034</b>, and event name field <b>1036</b>.

[0239] Such a data structure provides name collision protection between design entities but not within design entities. That is, the user must ensure that events names for events associated with a given design entity do not collide. In case of user error in this regard, model build tools may be utilized to detect an event name collision condition during model compilation. The alternative data structure depicted in FIG. 10D provides for simpler naming and referencing of events at the expense of requiring the user to prevent name collisions for events associated with a given design entity.

[0240] Returning to FIG. 10B, the combination of instrumentation entity field <b>1032</b>, design entity name field <b>1034</b>, and eventname field <b>1036</b> for a given event, provides a unique identifier for any given event without regard to multiple instantiations of the event. In order to uniquely distinguish between multiple instantiations of an event, instantiation identifier field <b>1030</b> is included in the extended event identifier. Instantiation identifier field <b>1030</b> field, by its construction, provides a unique string for any instance of an entity within any simulation model.

[0241] When evaluating occurrences of an event in a non-hierarchical sense, instantiation identifier field <b>1030</b> is ignored while searching for matching events. As illustrated in FIG. 10C, for example, a non-hierarchical query for the number of time a “count1” event occurs within design entity Z as detected by instrumentation entity B1, utilizes the following list of count eventnames: <tables id="TABLE-US-00003" num="3"><table frame="none" colsep="0" rowsep="0"><tgroup align="left" colsep="0" rowsep="0" cols="5"><colspec colname="OFFSET" colwidth="21PT" align="left" /><colspec colname="1" colwidth="49PT" align="left" /><colspec colname="2" colwidth="42PT" align="left" /><colspec colname="3" colwidth="42PT" align="left" /><colspec colname="4" colwidth="63PT" align="left" /><thead><row><entry /><entry /></row><row><entry /><entry namest="OFFSET" nameend="4" align="center" rowsep="1" /></row></thead><tbody valign="top"><row><entry /><entry>X1.Z</entry><entry>B1</entry><entry>Z</entry><entry>COUNT1</entry></row><row><entry /><entry>X2.Z</entry><entry>B1</entry><entry>Z</entry><entry>COUNT1</entry></row><row><entry /><entry>Y.Z</entry><entry>B1</entry><entry>Z</entry><entry>COUNT1.</entry></row><row><entry /><entry namest="OFFSET" nameend="4" align="center" rowsep="1" /></row></tbody></tgroup></table></tables>

[0242] These count events are added together to form an aggregate count of the total number of time the specific event occurred within the simulation model.

[0243] A hierarchical query includes specific criteria to match against the hierarchy field to limit the counter or counters found to specific instances of the requested event. For example, a query to obtain the count1 event of instrumentation entity B1 within the X1.Z instance of design entity Z utilizes the following count eventname:

[0244] X1.Z B1 Z COUNT1,

[0245] which represents the number of times the count1 event was counted by instrumentation entity B1 within design entity instance X1.Z for a particular simulation interval.

[0246] By providing matching model hierarchy criteria against instantiation identifier field <b>1030</b>, it is possible to consider the events with respect to their particular instance or instances within the model, i.e., a hierarchical query. A non-hierarchical query merely ignores the hierarchy field and returns all the instances of the requested events within the model.

[0247] With reference to FIG. 11A, there is depicted a block diagram illustrating a simulation model <b>1100</b> in which the hierarchical event processing of the present invention is applicable. Simulation model <b>1100</b> comprises atop-level design entity <b>1130</b> in which a pair of lower-level design entities <b>1102</b> and <b>1120</b> are instantiated. A design entity <b>1104</b> containing instrumentation entity <b>1106</b> is included within design entity <b>1102</b>. As illustrated in FIG. 11A, instrumentation entity <b>1106</b> includes logic <b>1110</b> for generating a simulation event <b>1108</b> from signal set <b>1132</b> from within design entity <b>1104</b>. Design entity <b>1120</b> includes an instrumentation entity <b>1122</b> that generates a simulation event <b>1124</b> using signal set <b>1134</b>.

[0248] Utilizing the techniques described hereinbefore, generating a hierarchical event that is some logical combination of events <b>1108</b> and <b>1124</b> requires the creation of an instrumentation entity associated with top level design entity <b>1130</b> that references signal sets <b>1132</b> and <b>1134</b>. Conventionally, such an instrumentation entity would substantially reproduce instrumentation logic <b>1110</b> and <b>1126</b> to process signal sets <b>1132</b> and <b>1134</b>, respectively, thus producing a copy of events <b>1108</b> and <b>1124</b>. Such a procedure is inefficient and prone to error. If, for example, changes are made to any or all of signal sets <b>1132</b> and <b>1134</b>, or instrumentation logic <b>1110</b> and <b>1126</b>, these changes would have to be accurately repeated in the instrumentation entity logic for the combined event.

[0249] The present invention provides a mechanism whereby events, such as events <b>1108</b> and <b>1124</b>, are directly referenced and utilized as inputs to cross-hierarchical instrumentation entities. In this manner, signal connections <b>1132</b> and <b>1134</b>, as well as instrumentation logic <b>1110</b> and <b>1126</b>, are directly re-utilized to produce the desired hierarchical event.

[0250] To facilitate direct referencing of events within simulation models, a specialized data structure is implemented within instrumentation entity input port map comment syntax. This data structure directly connects input ports of instrumentation entities to cross-hierarchical events within a simulation model.

[0251] For the embodiment depicted in FIG. 11A, an instrumentation entity <b>1150</b> is instantiated within top-level design entity <b>1130</b> to generate a hierarchical event <b>1156</b> that is some function of events <b>1108</b> and <b>1124</b>. As illustrated in FIG. 1A, instrumentation entity <b>1150</b> includes a pair of inputs <b>1151</b> and <b>1152</b> that are directly connected to events <b>1124</b> and <b>1108</b>, respectively, utilizing the augmented syntax described below. These input connections are logically combined using instrumentation logic <b>1154</b> to produce a cross-hierarchical event <b>1156</b>.

[0252] With reference to FIG. 11B, there is depicted a set of input port mapping comments for performing cross-hierarchical processing of simulation model events in accordance with the teachings of the present invention. In what follows, it is assumed that events <b>1108</b> and <b>1124</b> are count events with event names event_<b>1108</b> and event_<b>1124</b>, respectively, and that these events are connected to input ports event_<b>1108</b>_in and event_<b>1124</b>_in on instrumentation entity <b>1150</b>. As depicted in FIG. 11B, a first input port mapping comment <b>1161</b> contains data for referencing event <b>1108</b> to input port event_<b>1108</b>_in. A second input port mapping comment <b>1162</b> contains data for referencing event <b>1124</b> to input port event_<b>1124</b>_in. It should be noted that each of input port mapping comments <b>1161</b> and <b>1162</b> includes a pre-pended non-conventional comment identifier, --!!, that is utilized by the HDL compiler (such as compiler <b>462</b> in FIG. 4D) to maintain the port mapping comments separate from the design.

[0253] To facilitate connection of a simulation event to an instrumentation entity input port, input port mapping comments <b>1161</b> and <b>1162</b> consist of two distinct parts: an instance identifier and an event identifier. The instance identifier is a string consisting of instance names (in descending hierarchical order) of all design entities between and including the design entity containing the instrumentation entity of the cross-hierarchical event being defined (i.e., the highest level design entity for the cross-hierarchical event), and the design entity in which the event that is utilized in generating the cross-hierarchical event. If the design entity containing the hierarchical event is the same as the design entity containing the event to be connected to, the instance identifier is a null string. A pair of instance identifiers <b>1163</b> and <b>1164</b>, within input port mapping comments <b>1161</b> and <b>1162</b>, respectively, specify that events <b>1124</b> and <b>1108</b> originate from signals within design entity <b>1120</b> and <b>1104</b> respectively.

[0254] Input port mapping comments <b>1161</b> and <b>1162</b> further include event identifiers <b>1165</b> and <b>1166</b>, that identify input simulation events in terms of local instrumentation entities <b>1106</b> and <b>1122</b>, respectively. In accordance with the embodiment depicted in FIG. 11B, each event identifier consists of a string beginning with an open bracket (“[”) character and ending with a closed bracket (“]”) character. Between these brackets, three sub-strings, delineated by period (“.”) characters, comprise a data structure utilized to identify a specific event from which the cross-hierarchical event is defined. The first sub-string within an event identifier is the instance name of the instrumentation entity containing the event. The second sub-string is a string specifying the type of the event (“count”, “fail”, or “harvest”). Finally, the third sub-string is the event name of the given event as specified in the declaration comment for the event. Each event identifier string uniquely identifies a single event within a given design entity. As depicted in FIG. 11B, event identifier strings <b>1165</b> and <b>1166</b> identify events <b>1108</b> and <b>1124</b> respectively.

[0255] In accordance with an alternate embodiment of the present invention, the event identifier naming structure is modified slightly for events that are labeled in accordance with FIG. 10D (event names that do not include the instrumentation entity name). When an instrumentation identifier is absent from the extended event identifier, the event identifier string with an input port mapping comment consists of two sub-strings: a string denoting the type of event to connect to; and a string providing the name of the event separated by a period (“.”) character. The instrumentation entity name is not required in this case since all events of a given type associated with a given design entity will have unique names. The model build tools of the present invention will automatically search all instrumentation entities associated with the design entity called out by the instance identifier to determine which instrumentation entity generates an event having the name and type provided in the event identifier string.

[0256] Referring to FIG. 11C, there is illustrated a set of data structures for performing hierarchical processing of simulation model events in accordance with a second embodiment of the present invention. In the depicted embodiment, a pair of input port mapping comments <b>1171</b> and <b>1172</b> employ a syntax compatible with the event naming data structure depicted in FIG. 10D.

[0257] Input port mapping comment <b>1171</b> connects event <b>1108</b> to input port event_<b>1108</b>_in on instrumentation entity <b>1150</b>. Likewise, input port mapping comment <b>1172</b> connects event <b>1124</b> to input port event_<b>1124</b>_in on instrumentation entity <b>1150</b>. By utilizing the augmented syntax of FIG. 11B or FIG. 11C it is possible to create hierarchical events by connecting the inputs of instrumentation entities to events within the simulation model.

[0258] The above described system and method provides for practical instrumentation of simulation models and allows for efficient implementation of instrumentation logic through embedded instrumentation entities. Embedded instrumentation entities, as described hereinabove, are however necessarily limited to task-specific implementations. As described with reference to FIGS. 12A and 12B, the present invention further provides for a more flexible implementation of instrumentation logic in a more unstructured manner.

[0259] It is often necessary to tailor instrumentation logic to address unique problems and circumstances. Instrumentation logic of a specific and yet non-predefined nature that is designed in accordance with the techniques disclosed herein with reference to FIGS. 12A and 12B is referred herein as “random instrumentation logic.” A data construct consisting of general logic primitives (boolean operators, storage elements, etc.) and an interconnection method for these primitives is utilized for implementing such random instrumentation logic.

[0260] For instrumenting a simulation model as described heretofore, an HDL such as VHDL or Verilog is utilized as a platform from which instrumentation logic is generated. Appropriate instrumentation entity descriptor comments within design entity source code files couple the resultant instrumentation entities to designated target design entities within a simulation model.

[0261] In addition to entity descriptor comments within a design entity source code file, the foregoing instrumentation technique requires a separate HDL file in which the instrumentation entity is described. As explained with reference to FIGS. <b>12</b>A and <b>12</b>B, the present invention provides a method, system, and data structure for instrumenting design entities within a simulation model while avoiding the design process overhead required for creating a separate instrumentation entity HDL file.

[0262] In accordance with the teachings of the present invention, random instrumentation logic is directly deployed within target design entities in terms of individualized and customizable instrumentation descriptor comments. Such instrumentation descriptor comments are encoded within the target design entity HDL source code file and provide a means for the describing random instrumentation logic, events, and interconnections between the created instrumentation logic and the target design entity. The random instrumentation logic is inserted into the simulation model in a manner similar to the techniques used for embedded instrumentation entities to produce an instrumentation entity without the need for the creation of an explicit HDL instrumentation entity file.

[0263] With reference to FIG. 12A, there is illustrated a representative target design entity <b>1200</b> wherein random instrumentation logic is implemented in accordance with a preferred embodiment of the present invention. Instantiated within target design entity <b>1200</b> is a design entity <b>1201</b>. As further depicted in FIG. 12A, an instrumentation entity <b>1202</b> is instantiated within design entity <b>1201</b>. Instrumentation entity <b>1202</b> is designed in accordance with the principles set forth hereinabove to generate a count event <b>1203</b> having an event name “count1.” Target design entity <b>1200</b> further includes an instrumentation entity <b>1208</b> that is generated utilizing random instrumentation logic. As depicted in FIG. 12A, instrumentation entity <b>1208</b> receives as inputs signals P, A, B, and C along with count event <b>1203</b>.

[0264] Instrumentation entity <b>1208</b> is constructed by a set of unconventional comments lines within the source code file for target design entity <b>1200</b>. These comments may be incorporated at any point within the logic description section of the HDL source code file. HDL compiler <b>462</b> (FIG. 4B) recognizes the unconventional comments in addition to any comments utilized to instantiate embedded instrumentation entities within design entity <b>1200</b>. During the post-compilation/model build phase, instrumentation load tool <b>464</b> processes these comments in a manner similar to that utilized for embedded instrumentation entities (described with reference to FIGS. <b>10</b>A-<b>10</b>D) to generate instrumentation entity <b>1208</b>.

[0265] A variety of possible syntaxes can be utilized to formulate the unconventional HDL comments required for generating random instrumentation logic within the source code file of a target design entity. As depicted in FIG. 12B, much of the syntax of these comments employs syntax similar to the concurrent subset of the VHDL language with the addition of syntactic and semantic enhancements that provide a means of connection between an instrumentation entity and its target design entity. In addition, minor syntactic and semantic enhancements are provided to declare events and intermediate signals.

[0266] With reference now to FIG. 12B, there is illustrated an exemplary HDL source code file <b>1220</b> that describes design entity <b>1200</b>. Within HDL source code file <b>1220</b>, an entity instantiation <b>1221</b> produces design entity <b>1201</b>, and assignment statements <b>1222</b> are utilized to generate signals A, B, and C. A set of unconventional comments <b>1223</b> within HDL source code file <b>1220</b> is utilized to produce instrumentation entity <b>1208</b>. Comments <b>1223</b> are formulated as left-hand side (l.h.s.)/right-hand side (r.h.s.) assignment statements of the form:

{l.h.s.}&lt;={r.h.s.};

[0267] where {l.h.s.}, referred to herein after as lhs, is the assignment statement target and, {r.h.s}, referred to herein after as rhs is an expression denoting the logical value to be assigned to the statement lhs. A number of rules delineate the possible expressions for lhs and rhs in any legal statement in the instrumentation comments.

[0268] As employed within the instrumentation data structure of the present invention, an lhs statement may be either an event declaration or the name of a signal that is instantiated within an instrumentation entity. An event declaration is an expression within bracket characters (“[”, “]”) that generates a new event. Within comments <b>1223</b>, a statement <b>1230</b> produces a count event <b>1240</b> from instrumentation entity <b>1208</b> (FIG. 12A) having eventname “countname0”.

[0269] Within an lhs event declaration, a first field designates the event type (count, fail, harvest, etc.) and is followed by such other fields as are necessary to declare the event. As illustrated in lines <b>1230</b>, <b>1234</b>, and <b>1236</b>, such event declaration fields follow the same format as the event declaration fields depicted in FIG. 4C.

[0270] Comments <b>1223</b> further include a line <b>1232</b> having an lhs that declares a signal Q within instrumentation entity <b>1208</b>. To prevent ambiguity, any signal declared in this manner may not have a name corresponding to the name of any signal present on the top level of target design entity <b>1200</b>. Conformance to this requirement is verified by instrumentation load tool <b>464</b> (FIG. 4D) during processing. Signals declared by an lhs expression may be incorporated within an rhs expression as shown in lines <b>1232</b> and <b>1234</b>.

[0271] An rhs consists of logical connectivity expressions and/or functions that combine various signals. Signals within these connectivity expressions may originate from a number of possible sources including: signals declared on the lhs of a statement in the instrumentation comments; signals within the target design entity; or signals designating other events within the target design entity.

[0272] The absence of period (“.”) or bracket (“[”, “]”) characters within a signal value description in the rhs of a statement, designates the object signal as corresponding to either a signal within the top hierarchical level of the target design entity or to a signal declared on the lhs of a statement within the instrumentation language. Signals are named in a mutually exclusive manner by the rules governing creation of signals on the lhs of a statement in the instrumentation comments, thereby preventing any ambiguity in the determining the source of the given signal.

[0273] Signals in rhs connectivity expressions can also be connections to signals within entities instantiated within the target design entity. In such a circumstance, the instance names of the entity or entities in the hierarchy enclosing the desired signal are placed before the signal name in hierarchy order, delineated by period (“.”) characters. For example, the signal in statement <b>1230</b> (“Y.P”) represents signal <b>1204</b> within design entity <b>1201</b>. Signals at any level of the target design hierarchy are thus accessible to instrumentation logic generated by the instrumentation language comments.

[0274] Signals within the instrumentation comment expressions can also designate other events within the target entity. Event identifiers as described hereinbefore for hierarchical events are used to denote such “event” signals. For example, statement <b>1232</b> performs a logical AND of instrumentation event <b>1203</b> and signal A. The event identifier “Y.[B1.count.count1]” connects instrumentation entity <b>1208</b> to instrumentation event <b>1203</b>. This notation permits instrumentation events at any level of design hierarchy within target design entity <b>1200</b> to be directly accessed.

[0275] As further depicted in FIG. 12B, statement <b>1232</b> produces intermediate signal Q within instrumentation entity <b>1208</b>. This is an example of an instrumentation comment statement declaring a new intermediate signal. These signals can be used in other statements to construct random instrumentation logic of any desired depth or complexity.

[0276] Statement <b>1234</b> utilizes intermediate signal Q along with signal <b>1206</b> to produce fail event <b>1241</b>. The syntax for fail event declaration includes a field denoting the type of event (“fail”), a field giving the event name for the fail event (“failname0”), and a final field denoting the message to associate with the fail. Finally, statement <b>1236</b> produces harvest event <b>1242</b>.

[0277] In general, the rhs expression of any statement in the instrumentation data structure of the present invention can access any signal or instrumentation event signal within the target design entity utilizing these syntactic mechanisms. These signals can be combined to form new events or intermediate signals that can themselves be further combined to form instrumentation logic of any desired depth or complexity.

[0278] Instrumentation comments can be placed anywhere within the logic description section of the target entity source code file. All instrumentation comments within a file are considered as a whole and produce a single instrumentation entity within the target design entity.

[0279] It is often necessary to override signal values within a simulation model to test various functions and create certain conditions that would otherwise not be possible or simple to obtain. To provide an efficient and designer accessible means of overriding signal values within a simulation model, the present invention incorporates specialized signal override output ports and logic into instrumentation entities that permit bus signal overrides during model simulation. Such signal override output ports must have different names that the outputs for count, fail, and harvest events, and compliance with this condition is verified by instrumentation load tool <b>464</b> (FIG. 4D) during the model build process.

[0280] The signal override output ports may be declared explicitly as ports in the HDL source code file of an explicitly represented instrumentation entity. For an embedded instrumentation entity or instrumentation entities produced by random instrumentation logic comments within a target design entity, the signal override output ports are automatically generated by instrumentation load tool <b>464</b>. The signal override output ports are described in output port map statements that declare an alternate value that overrides a given simulation signal. Such an output port map statement further declares the conditions under which the simulation signal will be overridden. For each simulation signal (single or multi-bit) to be overridden, two output signals are produced: one providing the override signal value and another in the form of a single bit signal that enables or disables overriding of the simulation signal.

[0281] With reference to FIG. 13A, there is depicted an exemplary HDL design entity <b>1300</b> containing a multi-bit simulation signal R. Simulation signal R is driven by one or more sources within a logic module <b>1302</b>, and is received by one or more sinks within a logic module <b>1304</b>. While the present invention will be described with respect to overriding signal R, one skilled in the art will understand and appreciate the extensions necessary to apply the principles set forth herein to overriding single bit signals or subsets of multi-bit signals.

[0282] Referring to FIG. 13B, signal override functionality is incorporated within design entity <b>1300</b>. As illustrated in FIG. 13B, design entity <b>1300</b> includes an instrumentation entity <b>1306</b> that is equipped to override signal R. In the depicted embodiment, instrumentation entity <b>1306</b> produces a signal R_OV(0..4) that is utilized within HDL design entity <b>1300</b> to selectively replace signal R as an input into logic module <b>1304</b>. Instrumentation entity <b>1306</b> further produces a signal RT that enables an override of signal R with signal R_OV(0..4).

[0283] During a model build process, instrumentation load tool <b>464</b>, instantiates a multiplexor (MUX) <b>1308</b> that breaks the path of the original signal R as depicted in FIG. 13A to produce signal R′ that is input into logic module <b>1304</b>. MUX <b>1308</b> is directly instantiated by instrumentation load tool <b>464</b> into the design proto data structure for instrumentation entity <b>1306</b> without the need to alter the HDL source code for HDL design entity <b>1300</b>. MUX <b>1308</b> selects between override signal R_OV(0..4) and the original signal value R to determine the value of signal R′.

[0284] MUX <b>1308</b> is controlled by a select signal <b>1310</b> that is driven by logical AND gate <b>1312</b>. Logical AND gate <b>1312</b> is driven by signal RT and a latch bit signal from a latch <b>1314</b>. In a manner similar to that described in relation fail events in FIG. 5A, latch <b>1314</b>, when loaded with a binary ‘1’ value, forces MUX <b>1308</b> to select the original signal value R, thereby disabling overrides of signal R.

[0285] Instrumentation load tool <b>464</b> generates latch <b>1314</b> and logical AND gate <b>1312</b> for every overriddable signal within the simulation model. All signal overrides within a model can thus be selectively and individually disabled. For each overriddable signal, latch <b>1314</b> resides within instrumentation logic block <b>420</b> as depicted in FIG. 4B. In accordance with a preferred embodiment, only one instrumentation entity may override a given single bit signal or any signal or subset of signals within a multi-bit signal.

[0286] The signal override system of the present invention further provides a means by which instrumentation entities may access the original unaltered version of any given signal within the simulation model. As depicted in FIG. 13B, for example, instrumentation entity <b>1306</b> accesses the unaltered signal R by means of input signal <b>1320</b>.

[0287] With reference to FIG. 13C, there is illustrated an exemplary HDL source code file <b>1340</b> that describes instrumentation entity <b>1306</b>. HDL source code file <b>1340</b> includes entity descriptor comments <b>1351</b> and an architecture section <b>1358</b> comprising the functional logic within instrumentation entity <b>1306</b>.

[0288] Within HDL source code file <b>1340</b>, an input port map statement <b>1364</b> declares an input port <b>1309</b> at which instrumentation entity <b>1306</b> receives signal R from logic module <b>1302</b>. A set of output port map statements <b>1362</b> and <b>1363</b> define the output ports from instrumentation entity <b>1306</b> for signals R_OV(0..4) and RT, respectively.

[0289] An input port map comment <b>1360</b> connects signal input <b>1320</b> to instrumentation entity <b>1306</b>. Input port map comment <b>1360</b> employs an augmented syntax from that previously described for input port map comments. Signals that appear within brace (“{”, “}”) characters are defined to reference the original unaltered version of a signal within a particular target design entity. Hence the statement

[0290] --!! R_IN(0 to 4)=&gt;{R(0 to 4)}

[0291] connects input port R_IN to signal R in the altered design proto data structure. The brace syntax may be used to enclose any signal within a port map comment or any signal referred to within a random instrumentation comment statement RHS. If a signal referenced within braces has no associated override mechanism in the model, the signal declaration within braces merely resolves to the unaltered signal itself.

[0292] An additional comment section, output declarations <b>1361</b>, is further included within the descriptor comment syntax to declare signal overrides. Output declaration comment <b>1361</b> serves to generate the override logic shown in FIG. 13B and connect signals RT and R_OV(0..4) to the override logic. Output declarations such as output declaration comment <b>1361</b> are of the form:

[0293] --!!&lt;name&gt;:out_port=&gt;target_signal [ctrl_port];

[0294] where name is a name associated with the specific signal override (R_OVRRIDE in FIG. 13C), out_port is the output port providing the override value for the signal, target_signal is the name of the signal to be overriden, and ctrl ort is the single bit output port that determines when the target signal is overridden.

[0295] One such output declaration is required for every overridable signal. Signals designated by out_port and ctrl_port must appear as outputs declared in the HDL port map for the entity. As it does for instrumentation entities, instrumentation load tool <b>464</b> parses the comments depicted in FIG. 13C and alters the proto data structures within the simulation model at model build time to produce a result such as that depicted in FIG. 13B.

[0296] Furthermore, each signal override is given a unique name based on the “name” field within the output declaration comment in a manner analogous to that described earlier for count events. In this manner, each signal override can be specifically referred to for such purposes as disabling the signal override by setting latch <b>1314</b> as shown in FIG. 13B.

[0297] While FIG. 13C illustrates only those constructs necessary for implementing a signal override, it should be noted that there is no limitation placed upon the creation of count, fail, and harvest events within the same instrumentation entity as a signal override, and furthermore, that multiple signal override entities may be incorporated within the same instrumentation entity.

[0298] Referring to FIG. 13D, there is depicted an HDL source code file for producing design entity <b>1300</b> wherein a set of random instrumentation comments <b>1380</b> implement the logic necessary for selectively overriding signal R. A comment <b>1381</b> connects the unaltered version of signal R (referred to within the braces (“{“,”}”)syntax) to an internal instrumentation signal R_IN. A pair of comments <b>1382</b> and <b>1383</b> assign values for signals R_OV and RT (the exact expressions assigned to RT and R_OV are not depicted). An event declaration instrumentation comment <b>1384</b> produces a signal that enables signal R to be overridden. In accordance with the depicted embodiment, an event declaration comment is of the form:

[0299] [override, &lt;name&gt;, &lt;target signal&gt;, &lt;ctrl signal&gt;],

[0300] where override is a fixed string denoting a signal override, “&lt;name&gt;” is the name assigned to the override, “&lt;target_signal&gt;” is the name of the signal in the target entity to be altered, and “&lt;ctrl_signal&gt;” is the name of the signal that determines when the signal override takes effect. By utilizing random instrumentation comments, a design engineer can efficiently create signal overrides.

[0301] Since in accordance with the teachings of the present invention, signal overrides are implemented directly using hardware constructs, it is possible to efficiently utilize signal overrides within a hardware simulator.

[0302] Simulation of a given model is typically controlled by a program, hereinafter referred to as RTX (Run Time eXecutive), that is written in a high-level language such as C or C++. To facilitate RTX control and execution of a simulation run, simulators typically provide a number of application program interface (API) functions that may be called by the RTX. Such API functions employ routines, protocols, and tools that allow for polling of signals within the simulation model, alteration of signals within a simulation model, cycling a simulation model, etc.

[0303] The RTX is often required to monitor occurrences of significant events during model simulation. Such events typically consist of a signal or a set of signals that assume a prescribed sequence of values and will be referred to hereinafter as “model events.” To monitor model signals, an RTX typically calls a specialized API function, hereinafter referred to as GETFAC, which allows for polling of signal values during model simulation.

[0304] Typically, an RTX must monitor a large number of signals, potentially on a cycle-by-cycle basis, within a simulation model and must subsequently process the signal values in order to detect the occurrence of model events. This approach to model event monitoring places a burden on the verification engineer in terms of re-writing RTX and communicating with design engineers when the signals or sequence of signal values that constitute a model event change.

[0305] To provide an efficient means for monitoring model events, so-called “detection events” are generated and are accessible by the RTX. Such detection events are generated by instrumentation entities. Detection events are implemented as output ports on an instrumentation entity. Furthermore, an enhanced API function is provided for directly accessing detection events within a given simulation model.

[0306] For each detection event, a first, potentially multi-bit, output is utilized as the value of a model event. An optional second single bit signal is utilized to indicate when the detection event occurs during model simulation. By their nature, certain model events occur at each and every cycle and therefore do not require a qualifying signal to track their occurrences.

[0307] With reference to FIG. 14A, there is illustrated a block diagram depicting data content within main memory <b>44</b> (FIG. 2) during a simulation run of a simulation model <b>1400</b>. Main memory <b>44</b> includes the elements necessary for monitoring an exemplary model event including a software simulator <b>1410</b> that simulates simulation model <b>1400</b> under the control of an RTX <b>1405</b>.

[0308] RTX <b>1405</b> delivers a set of API calls <b>1430</b> to API function GETFAC within simulator <b>1410</b> to obtain the values of signals A, B, C, and D within model <b>1400</b>. Further processing of these signal events is performed utilizing an RTX code <b>1450</b> culminating in the assignment of the model event value to variable event_x at RTX code line <b>1455</b>.

[0309] Referring to FIG. 14B, there is illustrated a block diagram depicting contents of main memory <b>44</b> during a simulation run in accordance with a preferred embodiment of the present invention. In the depicted embodiment, an instrumentation entity <b>1460</b> is instantiated within simulation model <b>1400</b> using techniques described above. Instrumentation entity <b>1460</b> directly monitors signals A, B, C, and D by means of a set of signal connections <b>1462</b>. Signal connections <b>1462</b> provide a more efficient means to monitor signals than GETFAC API function calls.

[0310] Within instrumentation entity <b>1460</b>, instrumentation logic <b>1464</b> substantially recreates the function of RTX code <b>1450</b> of FIG. 14A and produces signals <b>1466</b> and <b>1468</b>, which denote the value of a model event and when the model event occurs, respectively.

[0311] Each detection event within a given simulation model is assigned a unique name in a manner described below. During model build, instrumentation load tool <b>464</b> (FIG. 4D) generates a data structure in the form of a table within the simulation model that uniquely names all the detection events within a given simulation model and the corresponding instrumentation entity output signals. This table will be referred to hereinafter as the detection event translation table.

[0312] An API function GETEVENT( ) is provided within software simulator <b>1410</b> for accessing model detection events. API function GETEVENT references a detection event translation table <b>1470</b> to locate signals <b>1466</b> and <b>1468</b> in response to a call <b>1472</b> by RTX to obtain the value of model event event_x. RTX <b>1405</b> obtains the value of model event event_x without delivering a number of GETFAC API calls, and furthermore, without the need to process the signal values associated with the model event. The RTX code is thus insulated from potential changes to the signals and signal sequence values defining model event event_x. Any changes to the detailed definition of model event event_x are reflected within instrumentation entity <b>1460</b> and no changes to the RTX are necessary.

[0313] With reference to FIG. 14C, there is illustrated an exemplary HDL source code file <b>1480</b> that describes instrumentation entity <b>1460</b> in accordance with a preferred embodiment of the present invention. As shown in FIG. 4C, exemplary file <b>1480</b> consists of a number of entity descriptor comments <b>1491</b> and an architecture section <b>1492</b> comprising instrumentation logic <b>1464</b>.

[0314] Within HDL file <b>1480</b>, a set of input port map comments <b>1493</b> serve to generate connections <b>1462</b> of FIG. 14B. An additional comment section, detection declarations <b>1494</b> is incorporated within the entity descriptor comment syntax that allows for declaring detection events. A detection declaration comment <b>1495</b> serves to generate and uniquely name detection event event_x. Moreover, detection declaration comment <b>1495</b> associates signals <b>1466</b> and <b>1468</b> of FIG. 14B with event_x. Detection event declarations, such as detection event declaration <b>1495</b> are of the form:

[0315] --!!&lt;name&gt;:event_value_port [ctrl_signal];

[0316] where name is a name associated with the specific detection event (event_x in FIG. 14C), event_value_port is the output port providing the value for the detection event, and ctrl_signal is an optional single bit output port that flags an occurrence of the model event.

[0317] Each detection event is uniquely named in accordance with the name field within the output declaration comment in a manner analogous to that described earlier for count events. Such detection event names, together with the corresponding instrumentation entity output ports, are inserted into the detection event translation table data structure that is placed within the model by instrumentation load tool <b>464</b>. API function GETEVENT receives the extended event identifier associated with a given event as an input and returns the model event value and, if applicable, an indication of whether the event occurred in the current cycle.

[0318] While FIG. 14C illustrates only those constructs necessary for implementing a detection event, the principles set forth herein place no limitation on the generation of count, fail, and harvest events or signal overrides within the same instrumentation entity as a detection event. Moreover, multiple detection events may be incorporated within the same instrumentation entity.

[0319] Within the spirit and scope of the present invention, detection events may be created within random instrumentation comments in a manner largely similar to that described with reference to signal overrides. Detection events can also be combined, in a manner similar to that shown earlier, as part of a hierarchical event.

[0320] Finally, it should be noted that the present invention may be practiced in conjunction with a hardware simulator. As for software simulators, hardware simulators are controlled by an RTX program. To adapt the principles set forth herein to a hardware simulator environment, the hardware simulator provides a GETEVENT API function and accept models containing a detection event translation table.

[0321] By utilizing random instrumentation comments, a design engineer can efficiently create representations of model events accessible to RTX. Such representations need not change even if the detailed definition of the model event changes. Such stability reduces the complexity and burden of maintaining RTX and lowers the amount of communication required between design and verification engineers.

[0322] In order to provide for the control and monitoring of instrumentation events within simulation models executing on a batch simulation farm, one or more general-purpose computers, hereinafter referred to as “instrumentation servers”, are added to batch simulation farms. An instrumentation server acts as a centralized repository for information used to control instrumentation events and for data gathered from instrumentation events during simulation runs. The exact nature and function of the control information and of the gathered data varies with the type of event (i.e. fail events vs. count events), as will be described below.

[0323] In order to allow for effective management of instrumentation events, a set of “eventlist” files (described with reference to FIGS. <b>10</b>A-D) contain information about the exact number and content of the instrumentation events in a given model. The eventlist files are created at model build time by instrumentation load tool <b>464</b>. These files, one per class of events (fail, count, harvest, etc.), list the particular events in the given simulation model. Each simulation model has a unique set of corresponding eventlist files that are created at model build time.

[0324] When instrumentation events are created at model build time, they are constructed in a specific order, and a unique index is assigned within the eventlist file to each instrumentation event for a given event class. Accesses to instrumentation events by API routines make use of these index values. Furthermore, when an API routine communicates aggregate data with respect to all events within a given event class to the instrumentation server, this aggregate data is sequentially ordered according to these index values.

[0325] Each eventlist file contains a list of the instrumentation events for a given event class within the model. These events are named in accordance with the naming convention data structures described above in conjunction with FIGS. <b>10</b>A-C, which provides unique names for each of the instrumentation events. Referring back to FIG. 10A in conjunction with FIG. 15, there is shown an eventlist file <b>1660</b> for the count events of simulation model <b>1000</b> of FIG. 10A.

[0326] Eventlist file <b>1660</b> contains multiple count event class entries <b>1663</b>. Each of count event class entries <b>1663</b> includes a unique, sequential index value <b>1661</b>, and an extended event identifier <b>1662</b>. Each of indices <b>1661</b> corresponds to the index of a particular event (in this case count event COUNT1) assigned at model build time. Extended event identifiers <b>1662</b> provide an event name associated with each individual event index. Eventlist file <b>1660</b> thus provides a mapping between the instrumentation event names and the instrumentation event indices as well as providing an ordering convention for aggregate data for a class of instrumentation events. Eventlist files, such as evenlist file <b>1660</b>, are used by the instrumentation server to aid in the control and monitoring of instrumentation events in simulation models.

[0327] With reference now to FIG. 16B, there is illustrated a batch simulation farm <b>1601</b> in which a preferred embodiment of the present invention may be implemented. Batch simulation farm <b>1601</b> consists of geographically distant simulation farm nodes <b>1680</b><i>a</i>-<i>d</i>. Within these nodes, general-purpose computers <b>1600</b><i>a</i>-<i>n </i>are interconnected via local area networks (LANs) <b>1610</b><i>a</i>-<i>d</i>. LANs <b>1610</b><i>a</i>-<i>d </i>are further connected by means of a wide-area network (WAN) <b>1690</b>, which provides communication among multiple simulation farm nodes <b>1680</b><i>a</i>-<i>d</i>. Those skilled in the art will recognize that many possible network topologies are possible for a batch simulation farm.

[0328] One such general-purpose computer <b>1607</b>, together with a set of disk storage devices <b>1609</b> serve as a shared file system, which is accessible to all general-purpose computers within simulation farm nodes <b>1680</b><i>a</i>-<i>d</i>. Exemplary batch simulation farm <b>1601</b> has been shown with one shared file system server in a particular geographic node. Those skilled in the art will recognize that it is possible for the shared file system to be implemented as multiple general-purpose computers and disk devices across the different geographic nodes in the batch simulation farm. Further, it is possible for each distinct geographic node to have a unique shared file system. Such unique file systems are usually accessible to all nodes, but are most advantageously accessed within the local network node wherein the file system resides.

[0329] Within simulation farm node <b>1680</b><i>a</i>, a particular general-purpose computer serves as an instrumentation server <b>1699</b>. Although a single instrumentation server is described with reference to the batch simulation farm environment shown in the figures, those skilled in the art will understand the extensions necessary to distribute the functionality of the instrumentation server across several physical general-purpose computers.

[0330] General-purpose computers <b>1600</b><i>a</i>-<i>n </i>within simulation farm nodes <b>1680</b><i>a</i>-<i>d </i>utilize software or hardware simulators to perform simulation tests on various digital design simulation models. In addition, certain designated general-purpose computers <b>1600</b> within batch simulation farm <b>1601</b> serve specific roles in the process of controlling and executing simulation tests as described below. Many of general-purpose computers <b>1600</b> may also be user machines that execute simulation tests as a secondary background function.

[0331] At any given time, a number of distinct versions of a simulation model for a given digital logic design may be undergoing simulation within batch simulation farm <b>1601</b>. In addition, a number of different digital designs, each with their respective differing model versions, may be undergoing simulation. In such circumstances, each different model is typically given a name, hereinafter referred to as the “model name”, which uniquely identifies both the particular digital design and the particular version of the simulation model for the given digital design.

[0332] One or more general-purpose computers <b>1600</b>, hereinafter referred to as “model servers”, are utilized to store the valid versions of simulation models currently available for execution within batch simulation farm <b>1601</b>. Before simulation jobs can be executed within batch simulation farm <b>1601</b> with respect to a particular model, that model must be built, and a copy of the model placed on the model servers. In addition, the eventlist files for the model must be placed on instrumentation server <b>1699</b> to allow for the control and monitoring of the instrumentation events.

[0333] Within batch simulation farm <b>1601</b>, one or more of general-purpose computers <b>1600</b><i>a</i>-<i>n</i>, referred to hereinafter as “testcase generators”, are typically utilized to create simulation testcases for the various models under simulation. The testcase generators are responsible for generating tests to be executed and further packaging these tests into simulation jobs. A simulation job is an entity containing the simulation test and any controlling information and/or programs (such as RTX) that are necessary to execute the simulation test within batch simulation farm <b>1601</b>.

[0334] Simulation jobs are passed from the testcase generators to one or more of general-purpose computers <b>1600</b><i>a</i>-<i>n </i>that are utilized as batch controllers, within batch simulation farm <b>1601</b>. These batch controllers are responsible for dispatching simulation jobs to a general-purpose computer utilized as a simulation platform, herein after referred to as a “simulation client”.

[0335] Once a simulation job arrives at a simulation client, the simulation client communicates with the model servers to obtain a copy of the simulation model corresponding to the particular simulation job. The model can be transferred to the simulation client by a number of means well known to those skilled in the art including, among others, a shared file system, File Transfer Protocol (FTP), or a custom file transport mechanism utilizing network communication protocols.

[0336] In addition, the simulation client communicates with instrumentation server <b>1699</b>, the shared file system comprising general-purpose computer <b>1607</b> and disk storage devices <b>1609</b>, or some combination thereof, in order to obtain the control information for the instrumentation events within the model. This control information is stored on a per model basis by model name on instrumentation server <b>1699</b>. The exact contents and nature of the communication between the simulation client and instrumentation server <b>1699</b> varies with the type of events within th e model as explained in further detail below. The instrumentation event control information is used by API routines called by RTX to control the behavior of the instrumentation events within the simulation model.

[0337] The simulation model is then loaded either into memory <b>44</b> or the hardware simulator within the simulation client. Model processing control is then passed to RTX for the execution of the simulation testcase. RTX executes the testcase until the successful completion of the test or an error condition (test fail) occurs.

[0338] Within batch simulation farm <b>1601</b>, one or more of general-purpose computers <b>1600</b><i>a</i>-<i>n</i>, hereinafter referred to as “statistics servers”, are utilized to store general statistics, such as cycles completed, number of passing tests executed, etc. concerning the execution of simulation jobs within batch simulation farm <b>1601</b>. Likewise, one or 1 more of general-purpose computers <b>1600</b><i>a</i>-<i>n</i>, hereinafter referred to as “failed testcase servers”, are utilized to store simulation tests that have failed in order to facilitate the re-execution and debugging of these testcases.

[0339] At the conclusion of the execution of a testcase, whether due to successful execution or a failure, RTX communicates with the statistics server to record general statistics about the execution of the simulation job. Such communication can be accomplished in a number of ways well known to those skilled in the art including a shared file system, a direct network connection between RTX and the statistics server, a file transport mechanism, and others.

[0340] At the conclusion of a testcase, RTX also communicates the aggregate information concerning instrumentation events to instrumentation server <b>1699</b>. This information is stored on instrumentation server <b>1699</b> for future analysis and in some cases is utilized to control instrumentation events in future simulation testcase runs for a given model. The exact nature of this communication varies for the different event classes as explained in further detail below.

[0341] If a testcase concludes due to a failure, RTX communicates with the failed testcase server to save those elements of the simulation job required to allow for the reproduction of the failed simulation testcase. The failed testcase server serves as a repository of failed tests that may be retrieved and re-executed in a foreground manner to allow for detailed investigation and problem resolution.

[0342] It is important to note that different simulation models typically require differing forms of testcases. What constitutes a testcase varies, often dramatically, between different simulation models. This is due to the varied techniques utilized in the present art for simulation of digital systems. In such circumstances, the failed testcase servers provide mechanisms capable of storing each of the various different forms of testcases.

[0343] In response to RTX communicating the general statistics for a simulation job to the statistics servers, communicating the aggregate statistics for the instrumentation events to instrumentation server <b>1699</b>, and arranging for the storage of any failed simulation testcases on the failed testcase servers, RTX terminates and the simulation client is released. The batch controllers can then dispatch a new simulation job to the simulation client for execution. Those skilled in the art will recognize that many potential variations in the operation of a batch simulation farm are possible.

[0344] With reference to the flowchart of FIG. 16C in conjunction with FIG. 15, there is depicted a progression of events from the creation of a specific simulation model to the removal of that model from batch simulation farm <b>1601</b> and instrumentation server <b>1699</b>. The process begins at step <b>1621</b>, which depicts the creation of the given simulation model. The simulation model is created in accordance with model build processes described hereinbefore.

[0345] Proceeding to step <b>1622</b>, the model is placed on the model server to be available for simulation jobs executed within batch simulation farm <b>1601</b>. Next, as illustrated at step <b>1655</b>, the model eventlist files are placed on instrumentation server <b>1699</b>. Once the eventlist files for a given model are placed on instrumentation server <b>1699</b>, instrumentation server <b>1699</b> begins controlling instrumentation events and gathering instrumentation event data for the given model. Placing the eventlist files on instrumentation server <b>1699</b> will be referred to hereinafter as “commissioning” a model.

[0346] The process continues as depicted at step <b>1623</b>, with a determination of whether all the desired testing for the given model has been completed. If, as illustrated at step <b>1625</b>, all testing for the given model is not complete, a new testcase is generated by the testcase generators. Subsequent to generation of a new testcase, a batch controller dispatches the resultant simulation job to a simulation client for execution as shown at step <b>1626</b>. The simulation job is then executed on the simulation client as depicted at step <b>1627</b>. Finally, the process returns to step <b>1623</b> to repeat until model testing for the given model is complete and the model is removed from the batch simulation farm as illustrated at step <b>1624</b>.

[0347] Those skilled in the art will recognize that it is possible for several concurrent simulation jobs for the same model to be executing contemporaneously within batch simulation farm <b>1601</b>. That is to say, steps <b>1625</b>-<b>1627</b> may be executed with respect to the same model a number of times concurrently by batch controllers within batch simulation farm <b>1601</b>. The given simulation model is not removed from batch simulation farm <b>1601</b> until all outstanding jobs, potentially executing concurrently, for the given simulation model have completed execution. Referring to step <b>1624</b>, when all testing for the model has been completed, the model is removed from the model servers and therefore from batch simulation farm <b>1601</b>.

[0348] It is often necessary to access particular elements of the instrumentation data for a particular model even after the model has been removed from batch simulation farm <b>1601</b>. Process step <b>1628</b> depicts a determination of whether there still exists a need for access to the instrumentation data stored within instrumentation server <b>1699</b> for the given model. In response to a determination that all necessary access to instrumentation data for the model has been completed, the process continues as shown at step <b>1629</b>, with the eventlist files, control information, and instrumentation data files for the given model all being removed from instrumentation server <b>1699</b>, thereby removing the model in its entirety from instrumentation server <b>1699</b>.

[0349] With reference to the flowchart of FIG. 16D, the steps involved in simulation job execution step <b>1627</b> of FIG. 16C are depicted in greater detail. The process of executing a simulation job on a simulation client begins with step <b>1631</b>, which depicts the simulation client obtaining a copy of the model corresponding to the given simulation job provided by the model servers. As illustrated at step <b>1638</b>, the simulation client communicates with instrumentation server <b>1699</b> to obtain and process control information for the instrumentation events within the simulation model. Proceeding to step <b>1632</b>, the simulation model is loaded into a hardware simulator or memory <b>44</b> of the simulation client.

[0350] The process then moves to step <b>1633</b>, which depicts the execution of the simulation test under RTX control. Once the simulation test is complete, and as illustrated at step <b>1634</b>, RTX delivers the aggregate statistical results data obtained from the simulation job to the statistics server wherein the data are logged. Next, as depicted at step <b>1635</b>, a determination is made of whether or not the testcase failed. If the testcase has failed, and as shown at step <b>1636</b>, the RTX communicates the failed testcase to the failed testcase servers. If it is determined at step <b>1635</b> that the testcase did not fail, the process continues at step <b>1637</b>, which depicts RTX delivering various aggregate instrumentation event data to the instrumentation server <b>1699</b> as will be described below. The process concludes with step <b>1639</b>, illustrating the simulation client being released to perform other simulation jobs.

[0351] In an environment such as batch simulation farm <b>1601</b>, which contains a potentially large number of different versions of active simulation models, it is important to ensure the correctness of the aggregate instrumentation data communicated from the simulation clients to the instrumentation server for the various models. Each simulation model contains a unique set of instrumentation events that are ordered, per class of events, in a unique fashion. The nature and identity of these sets of events are delivered to instrumentation server <b>1699</b> when the eventlist files for each model are commissioned onto instrumentation server <b>1699</b>.

[0352] Aggregate data about a group of instrumentation events delivered from a simulation client are identified by the model name within instrumentation server <b>1699</b>. Once a particular simulation model is commissioned (i.e. the eventlist files for the model has been placed on instrumentation server <b>1699</b>), it may be useful to enable instrumentation server <b>1699</b> to determine if the aggregate instrumentation data received under a given model name correctly corresponds to the instrumentation data for the model named in accordance with the model name originally commissioned on instrumentation server <b>1699</b>.

[0353] Simulation clients <b>1600</b><i>a</i>-<i>n </i>may also be utilized to simulate a model directly in a foreground mode without using the batch simulation farm. Such a foreground simulation does not require the placement of a model on the model servers or the placement of the eventlist files on the instrumentation server. Such independent model processing is one possibility necessitating a method for ensuring consistency of eventlist model data within instrumentation server <b>1699</b>. To provide a means to uniquely correlate aggregate instrumentation data to a specific simulation model, instrumentation load tool <b>464</b> places a number of so-called “digital signatures” within each simulation model. These signatures are computed for each instrumentation event class and are subsequently utilized by a cyclic-redundancy-check (CRC) check function to ensure an exact correspondence between models commissioned within instrumentation server <b>1699</b> and subsequently arriving model event information. As explained in further detail with reference to FIGS. <b>17</b>A-C, a digital signature is generated that uniquely corresponds to the eventlist contents for each event class. The digital signature is computed from the eventlist data for a given set of events within a specific simulation model. Any alterations, additions, or deletions to an eventlist file will result in a differing digital signature.

[0354] The use of CRC values is well known to those skilled in the art and they are used in a variety of other circumstances to detect corruption of data during transmission or storage. As implemented herein, however, the CRC “digital signature” serves not to detect errors in the physical transmission or storage of data, but rather as a unique signature for the contents of an eventlist file for a simulation model. For example, if a model with a different set of instrumentation events is created, but given the same name as an earlier model, the contents of the eventlists are changed and therefore the value of the CRC digital signatures will differ from those of the original model.

[0355] Referring to FIG. 17A, there is illustrated a block diagram depicting data content within main memory <b>44</b> (FIG. 2), including a simulation client <b>1701</b>, during a simulation run of a simulation model <b>1700</b> in accordance with a preferred embodiment of the present invention. Within simulation model <b>1700</b>, digital signatures <b>1710</b><i>a</i>-<i>n </i>correspond to a CRC value calculated by instrumentation load tool <b>464</b> for the various eventlists describing all instrumentation events contained in simulation model <b>1700</b>.

[0356] At the conclusion of a simulation run, an RTX <b>1702</b> communicates aggregate instrumentation event data to instrumentation server <b>1699</b>, as depicted in step <b>1637</b> of FIG. 16D. To communicate the aggregate event instrumentation data, RTX <b>1702</b> calls API entry point <b>1740</b> within a simulator <b>1735</b>. API entry point routine <b>1740</b> collects the instrumentation event data into an “aggregate data packet” (depicted in FIG. 17B), which is delivered to instrumentation server <b>1699</b> through a network interface <b>1720</b>. Distinct API entry points are provided for each class of instrumentation events that must communicate aggregate data with instrumentation server <b>1699</b>.

[0357] With reference to FIG. 17B, an aggregate data packet <b>1750</b>, such as that delivered by API entry point routine <b>1740</b> to instrumentation server <b>1699</b>, is depicted. Aggregate data packet <b>1750</b> contains a model name field <b>1751</b>, a CRC digital signature value <b>1752</b>, and a data field <b>1753</b>. Model name field <b>1751</b> consists of the name of simulation model <b>1700</b>. CRC digital signature value <b>1752</b> contains the digital signature value for the class of events communicated in aggregate data packet <b>1750</b>. Data field <b>1753</b> contains the aggregate instrumentation event data for model <b>1700</b>. The nature and contents of this data varies for each class of instrumentation events.

[0358] Referring to FIG. 17C, there is shown a process by which model event data for aggregate data packets received by instrumentation server <b>1699</b> is validated in accordance with a preferred embodiment of the present invention. The process begins at step <b>1770</b> with instrumentation server <b>1699</b> receiving an eventlist for a specific model during model commissioning. Next, as illustrated at step <b>1772</b>, instrumentation server <b>1699</b> computes and stores a CRC digital signature uniquely characterized by the contents of the eventlist. Instrumentation server <b>1699</b> employs the same CRC computation function as that utilized by instrumentation load tool <b>464</b> to generate the CRC digital signature value such as CRC value <b>1752</b>.

[0359] Proceeding to step <b>1774</b>, instrumentation server <b>1699</b> receives an aggregate data packet structured as depicted in FIG. 17B from simulation client <b>1701</b>. It should be noted that the CRC value contained with the aggregate packet received at step <b>1174</b> was previously computed and stored by instrumentation load tool <b>464</b>. The process continues as depicted at step <b>1776</b>, with a determination of whether or not the aggregate data packet corresponds to a model and event class that has previously been commissioned with instrumentation server <b>1699</b>. If not, and as illustrated at step <b>1782</b>, the packet is discarded. If, however, the aggregate data packet corresponds to a class of event for a model name commissioned on instrumentation server <b>1699</b>, the process proceeds to step <b>1778</b>.

[0360] Step <b>1778</b> depicts a determination of whether or not the CRC digital signature contained within aggregate data packet <b>1750</b> matches the CRC value computed and stored at step <b>1772</b>. If the CRC check values match, and as illustrated at step <b>1780</b>, the packet is processed. The exact nature of the processing varies with the type of packet as explained in further detail below. If the CRC check values do not match, the packet is discarded as depicted at step <b>1782</b>. Following either packet processing (step <b>1780</b>) or packet discard (step <b>1782</b>), the process returns to step <b>1774</b> at which a next arriving aggregate data packet is received.

[0361] By calculating and storing a CRC digital signature value for each eventlist received when models are commissioned, instrumentation server <b>1699</b> can verify that each aggregate data packet received for a given model name matches the data contents of the model having that name when originally commissioned on the instrumentation server. In this manner, instrumentation server <b>1699</b> can ensure that the data received corresponds to the model (as defined by the model name) as that model was defined at the time it was commissioned.

[0362] In the context of a batch simulation farm, it is advantageous to provide a means to centrally disable instrumentation events without the need to recompile or redistribute simulation models. Such a mechanism is particularly useful for centrally disabling a faulty or undesired fail instrumentation event within a simulation model that may be simulated within any number of simulation clients within the batch simulation farm.

[0363] Faulty fail instrumentation events may result in a large number of testcases being erroneously reported as failing and subsequently being erroneously stored for analysis. Although the following description of centralized instrumentation event disablement is explained only for fail events, one skilled in the art will appreciate that similar techniques could be applied to instrumentation event types other than fail events.

[0364]FIG. 18A illustrates contents of memory <b>44</b> within simulation client <b>1701</b> during execution of a simulation job. Prior to execution of the simulation job, RTX <b>1702</b>, as part of step <b>1638</b> of FIG. 16D, calls API entry point <b>1800</b>, disable_events( ). API entry point <b>1800</b> is a routine that communicates with instrumentation server <b>1699</b> and/or shared file system <b>1609</b> to obtain a list of events to be disabled, hereafter referred to as a “fail disable list”. Separate, initially empty fail disable lists are stored for each active model within batch simulation farm <b>1601</b>.

[0365] Once the fail disable list is obtained by RTX <b>1702</b>, API entry point <b>1800</b> further calls API entry point <b>1802</b>, set_fail_mask( ), to disable the specific failure events listed in the retrieved fail disable list. To disable, or mask, the fail events specified in the fail disable list, API entry point <b>1802</b> sets appropriate fail mask registers <b>507</b><i>a</i>-<i>n </i>as described with reference to FIG. 5A.

[0366] API entry point <b>1800</b> obtains the fail disable list from one of two sources. The first source is a master file <b>1805</b> stored on disk in instrumentation server <b>1699</b>. The second possible source is from an auxiliary file <b>1807</b> stored in association with general purpose comptuter <b>1607</b> in shared file system <b>1609</b>. Master file <b>1805</b> serves as the primary copy of the fail disable list. At regular intervals, instrumentation server <b>1699</b> copies the contents of master file <b>1805</b> into auxiliary file <b>1807</b>, which serves as a backup copy of the fail disable list.

[0367] The two-file system depicted in FIG. 18A is used to maintain the fail disable list in a flexible and robust manner within geographically distributed simulation farm <b>1601</b>. Simulation clients that obtain the fail disable list from shared file system <b>1609</b> can potentially receive a “stale” copy of the disable fail list. In practice, this may not pose a problem since master file <b>1805</b> is copied onto auxiliary file <b>1807</b> on a regular interval, and any discrepancies between master file <b>1805</b> and auxiliary file <b>1807</b> are quickly reconciled.

[0368] In one implementation, simulation clients within the same local area network as instrumentation server <b>1699</b> are configured to primarily obtain the fail disable list by direct communication with instrumentation server <b>1699</b>. In response to a communication failure with instrumentation server <b>1699</b>, the simulation clients would attempt to obtain the fail disable list from shared file system <b>1609</b>, which may reside within or outside the requestor's local area.

[0369] A direct network connection with a geographically remote instrumentation server can potentially be more error prone and have lower performance than a local connection to a geographically local shared file system. Therefore, simulation clients that are geographically remote (i.e. not in the same local area network) with respect to instrumentation server <b>1699</b>, maybe configured to initially attempt to obtain the disable fail list from a local shared file system. In alternate implementations, simulation clients maybe configured to obtain the fail disable list from shared file system <b>1609</b> in order to reduce network traffic to instrumentation server <b>1699</b>. By having two separate sources for the fail disable list, the simulation clients can be configured to balance the traffic between instrumentation server <b>1699</b> and shared file systems <b>1609</b>.

[0370] Referring to the flowchart of FIG. 18B, wherein is depicted the processes performed with respect to API entry point <b>1800</b> in greater detail. As shown in FIG. 18B, the process begins with a fail list request by RTX <b>1702</b> as depicted at step <b>1829</b>. In response to the RTX request, and as illustrated at step <b>1830</b>, a determination is made of whether or not an attempt should be made to access instrumentation server <b>1699</b> to obtain the disable failure list. If a determination is made not to attempt to access the fail disable list from instrumentation server <b>1699</b>, the process continues at step <b>1836</b>, with a further determination of whether or not to access shared file system <b>1609</b>. Otherwise, as illustrated at step <b>1832</b>, simulation client <b>1701</b> attempts to obtain the fail disable list from instrumentation server <b>1699</b>.

[0371] Proceeding to step <b>1834</b>, if the attempt to access instrumentation server <b>1699</b> was successful, the fail events specified in the fail disable list are disabled via API entry points <b>1800</b> and <b>1802</b> as illustrated at step <b>1844</b>. In the case of an unsuccessful attempt to access instrumentation server <b>1699</b>, and as depicted at step <b>1836</b>, a further determination is made of whether to attempt to access shared file system <b>1609</b> in an alternative attempt to obtain the fail disable list. As depicted at steps <b>1838</b>, <b>1840</b>, and <b>1844</b>, the fail events specified in the fail disable list are disabled (i.e. API entry point <b>1800</b> calls API entry point <b>1802</b> to disable the designated failure events) in response to simulation client <b>1701</b> successfully accessing shared file system <b>1609</b>. The failure event disablement process concludes step <b>1846</b>, depicting API entry point returning a successful disablement indication to RTX <b>1702</b>. If the attempt to access shared file system <b>1609</b> is unsuccessful, the process concludes with step <b>1842</b>, illustrating API call <b>1800</b> returning an indication to RTX <b>1702</b> that the attempt to mask the failure events failed.

[0372] To initiate disablement of one or more fail events for a given simulation model, a user adds an entry to a fail disable list associated with the simulation model within master file <b>1805</b>. Subsequently, simulation clients utilizing the fail disable list within master file <b>1805</b> will disable the fail event(s) for the particular simulation model in accordance with the process illustrated in FIG. 18B. At a predetermined interval, the fail disable list within master file <b>1805</b> is delivered to replace the failure disable list within auxiliary file <b>1807</b>, and the currently active simulation clients will disable the failure event(s) specified in the updated list for the specified model.

[0373] Within a fail disable list file, fail events are specified by entries corresponding in structure to the event identifiers for failure events with possible wildcard extensions in the various eventname fields. Such wildcard extensions permit, for example, the automatic disablement of all the replicated instances of a given failure event without having to explicitly list all the instances of the failure event. However, by utilizing entries without wildcards within the failure disable file, the failure disable list provides the ability to selectively disable specific individual failure event instances as well.

[0374]FIGS. 18A and 18B illustrate a user-initiated mechanism for centrally disabling fail events within a batch simulation farm environment. Typically, batch simulation farms run continuously and cannot be directly monitored at all times. As will be explained with reference to FIGS. 19A and 19B, the present invention provides an autonomous means of disabling failure events that does not require active user intervention.

[0375] With reference to FIG. 19A, there is depicted contents of memory <b>44</b> within simulation client <b>1701</b> at the conclusion of a simulation job in accordance with a preferred embodiment of the present invention. Simulation model <b>1700</b> contains fail events identified within fail event flag registers <b>500</b><i>a</i>-<i>n </i>as described hereinbefore in conjunction with FIG. 5A. Signal <b>511</b>, driven by logical OR gate <b>512</b>, indicates the occurrence of a failure event during a simulation job.

[0376] As part of step <b>1637</b> of FIG. 16D, RTX <b>1702</b> calls an API entry point <b>1900</b>, report_fails( ). API entry point <b>1900</b> first examines signal <b>511</b> to determine if any of the fail events specified within flag registers <b>500</b><i>a</i>-<i>n </i>have occurred during a simulation run. If none of the specified failure events have occurred, API entry point <b>1900</b> terminates further action.

[0377] However, if one or more of the specified failure events have occurred during the simulation run, API entry point <b>1900</b> generates and delivers a corresponding aggregate data packet for the occurring failure events via network interface <b>1720</b> to instrumentation server <b>1699</b>. The contents of registers <b>500</b><i>a</i>-<i>n </i>are contained, for example, in the data field of the aggregate data packet delivered to instrumentation server <b>1699</b>. In this manner, instrumentation server <b>1699</b> receives information for every failure event that occurs within batch simulation farm <b>1601</b>. In accordance with the depicted embodiment, instrumentation server <b>1699</b> maintains a set of counters <b>1901</b>, one set per commissioned model, to monitor the rate of occurrence for individual failure events.

[0378] After verifying the correctness of the fail event aggregate data packet, in accordance with the process described above with reference to FIG. 17C, instrumentation server <b>1699</b> increments counters <b>1901</b> to record the occurrence of the failure events in model <b>1700</b>. Contemporaneously with processing aggregate failure event data packets, instrumentation server <b>1699</b> decrements counters <b>1901</b> at a regular interval. In this manner, counters <b>1901</b> indicate the number of times a failure event has occurred within a given time interval rather than the total number of times a failure event has occurred. The interval at which counters <b>1901</b> are decremented is a predetermined value that can be adjusted.

[0379] Within counters <b>1901</b>, only one counter is provided per specific fail event without regard to the differing instances of the specific fail event. That is to say, failure events are considered in a non-hierarchical sense as described above. Occurrences of fail events from all instances of a given fail event are added into a single counter. Each of counters <b>1901</b> therefore represents the rate at which a given failure event occurs, irrespective of which instance or instances of the failure event occur. In practice, it is preferable to consider failure events in a non-hierarchical sense, since, in general, the significance of a given failure event does not depend on where in simulation model <b>1700</b> the failure occurs.

[0380] Referring to FIG. 19B, there is depicted a flow diagram of a process by which instrumentation server <b>1699</b> processes fail event aggregate data packets in accordance with a preferred embodiment of the present invention. The process begins at step <b>1910</b> and proceeds to step <b>1912</b>, which depicts instrumentation server <b>1699</b> receiving a fail event aggregate data packet. The process continues with step <b>1914</b>, illustrating a determination of whether or not the aggregate data packet corresponds to a model commissioned within instrumentation server <b>1699</b> in accordance with the digital signature verification method explained with reference to FIGS. <b>17</b>A-C. If the aggregate data packet cannot be verified, it is discarded as illustrated at step <b>1916</b>.

[0381] Otherwise, if the aggregate data packet has been verified as corresponding to a commissioned model, counters <b>1901</b> are incremented in accordance with packet data content within instrumentation server <b>1699</b> as depicted at step <b>1918</b>. The fail threshold process of the depicted embodiment is based on rates of occurrences of fail events rather than a cumulative evaluation. To this end, and as depicted at steps <b>1925</b> and <b>1927</b>, all of counters <b>1901</b> are decremented at a predetermined time interval during processing of received aggregate fail event packets.

[0382] Following counter incrementation, and as illustrated at step <b>1920</b>, a determination is made of whether or not any of counters <b>1901</b> has exceeded a predetermined threshold. Any counter having exceeded this threshold indicates that a given fail event is occurring at too frequently (i.e. at an excessive rate). Responsive to a determination that any of counters <b>1901</b> has exceeded its threshold, the process continues as illustrated at step <b>1922</b>, with instrumentation server <b>1699</b> adding an entry for the excessively occurring fail event into the fail disable list within master file <b>1805</b>. This entry disables all instances of the problematic failure event within simulation model <b>1700</b>, and with respect to the disabled failure event, the process terminates as shown at step <b>1924</b>.

[0383] If, as determined at step <b>1920</b>, no counters have exceeded the threshold, the fail threshold process terminates as shown at step <b>1924</b> with respect to the packet received at step <b>1912</b>. Instrumentation server <b>1699</b> repeats the steps depicted in FIG. 19B for each fail event aggregate data packet received from API entry point <b>1900</b>, report_fails( ).

[0384] The process illustrated in FIG. 19B provides a means by which instrumentation server <b>1699</b> monitors the occurrence of failure events within simulation models executed on batch simulation farm <b>1601</b>. When a given failure event occurs faster than a certain threshold, instrumentation server <b>1699</b> automatically disables the failure event. This process occurs without the need for user intervention.

[0385] In an environment such as batch simulation farm <b>1601</b>, it is common for a given design entity to be utilized in a number of different models of varying complexity and size. A given design entity may appear in different models ranging in complexity from a model containing a subset of the integrated circuit in which the entity resides to a model containing an entire system with potentially multiple instances of the physical chip in which the design entity resides. Furthermore, there may be several versions of each of these different models active within batch simulation farm <b>1601</b> at any given time.

[0386] In such an environment, it advantageous to provide a means that allows an HDL circuit designer to access count event data for a given design entity without requiring specific knowledge of which active models in the batch simulation farm contain that design entity. In practice, designers are generally not aware of the specifics of the models active in a batch simulation farm at any given time.

[0387] In addition, once a designer registers a request for count event data, it is useful if this request can be repeated without user intervention at specified intervals, and that the counter data be returned automatically to the designer's workstation for on-going evaluation. In the following description, a request (from an HDL designer, for example) for counter data submitted within a batch simulation farm environment will be referred to as a “counter query”. Counter queries are delivered from one of general-purpose computers <b>1600</b> to instrumentation server <b>1699</b> for storage and processing. In accordance with the embodiments described herein, a separate list of counter queries is maintained for each individual user.

[0388] With reference to FIG. 20A, there is depicted the contents of memory <b>44</b> at the conclusion of a simulation processing job performed with respect to simulation model <b>1700</b> within simulation client <b>1701</b>. Simulation model <b>1700</b> contains count event registers <b>421</b><i>a</i>-<b>421</b><i>n </i>as described hereinbefore with reference to FIG. 4B. Each of count event registers <b>421</b><i>a</i>-<b>421</b><i>n </i>maintains a count representing the number of times a particular instrumentation count event has occurred during the simulation of simulation model <b>1700</b>.

[0389] As part of step <b>1637</b> of FIG. 16D, RTX <b>1702</b> calls an API entry point rpt_counts( ) <b>2000</b>. API entry point <b>2000</b> generates and delivers an aggregate data packet containing the results registered in count event registers <b>421</b><i>a</i>-<b>421</b><i>n </i>to instrumentation server <b>1699</b> via network <b>1720</b>. Upon receipt of the aggregate count event data packet, instrumentation server <b>1699</b> confirms that the packet information corresponds to a commissioned simulation model utilizing a CRC digital signature as described with reference to FIGS. <b>17</b>A-<b>17</b>C. If the aggregate data packet corresponds to a commissioned model, instrumentation server <b>1699</b> stores the count data within the aggregate count event packet in a set of count data storage files <b>2001</b><i>a</i>-<b>2001</b><i>n. </i>

[0390]FIG. 20B depicts an exemplary aggregate count event packet <b>2010</b> in accordance with a preferred embodiment of the present invention. Similar to aggregate data packet <b>1750</b> of FIG. 17B, aggregate count event packet <b>2010</b>, includes model name field <b>1751</b>, CRC digital signature field <b>1752</b>, and data field <b>1753</b>. Within data field <b>1753</b>, a cycle count field <b>2011</b> contains a count value representing the number of cycles executed during the simulation run from which aggregate count event packet <b>2010</b> was generated. A set of count value fields <b>2012</b><i>a</i>-<i>n </i>contain the count values for each of the count events instantiated within simulation model <b>1700</b> in the order set forth by the count eventlist file created at model build time.

[0391] Within instrumentation server <b>1699</b> depicted in FIG. 20A, the count event data contained in the count value fields for one or more aggregate count event packets is stored in count data storage files <b>2001</b><i>a</i>-<i>n</i>. Each of count data storage files <b>2001</b><i>a</i>-<i>n </i>therefore contains all recorded counts for a given predetermined time interval (typically a day) for a specified simulation model. When instrumentation server <b>1699</b> receives and confirms the commissioned status of aggregate count event packet <b>2010</b>, one of count data storage files <b>2001</b><i>a</i>-<i>n </i>is either created or updated as necessary to store the contents of the received aggregate count data packet <b>2010</b>.

[0392] Referring to FIG. 20C there is illustrated the contents of an exemplary count data storage file <b>2001</b> among count data storage files <b>2001</b><i>a</i>-<i>n</i>. Within count data storage file <b>2001</b>, a cumulative cycle count field <b>2020</b> represents the cumulative number of cycles simulated during every simulation run for which count data is added into count data storage file <b>2001</b> over the aforementioned predetermined time interval. A set of cumulative count fields <b>2021</b><i>a</i>-<b>2021</b><i>n </i>contain the cumulative number of occurrences of each corresponding count event included within count value fields <b>2012</b><i>a</i>-<b>2012</b><i>n </i>for each aggregate count event packet received by instrumentation server <b>1699</b>. In summary, when aggregate count event packet <b>2010</b> is received and verified by instrumentation server <b>1699</b>, cycle count field <b>2011</b> is added to cumulative cycle count field <b>2020</b> and likewise, count value fields <b>2012</b><i>a</i>-<b>2012</b><i>n </i>are added to corresponding cumulative count value fields <b>2021</b><i>a</i>-<b>2021</b><i>n</i>. Count data storage file <b>2001</b> therefore contains a cumulative total of the number of cycles executed on the given simulation model and the number of times each count event has occurred over a pre-designated time interval which in the depicted embodiment is a day.

[0393]FIG. 20D illustrates a directory structure implemented within instrumentation server <b>1699</b> for storing count data storage files <b>2001</b><i>a</i>-<b>2001</b><i>n</i>. All count data is stored under a counter storage directory <b>2030</b> on a disk storage unit <b>2007</b> within instrumentation server <b>1699</b>. As depicted in FIG. 20D, counter storage directory <b>2030</b> is further divided into a two-tier subdirectory structure.

[0394] A first tier of subdirectories <b>2031</b> is utilized to associate count data contained within a received aggregate count event packet with a particular time period (e.g. a specific date) in accordance with a pre-designated time increment. In the embodiment depicted in FIG. 20D, this pre-designated time increment is a day (i.e. one 24-hour period). Each of subdirectories <b>2031</b> therefore contains the count data for all simulation models received on a particular date. Each of subdirectories <b>2031</b> is named in a fixed manner that is derived from the date on which the subdirectory was created. In association with each of subdirectories <b>2031</b>, a second tier of subdirectories <b>2032</b> is utilized to divide the count data received by instrumentation server <b>1699</b> on a given day into directories indexed on a per-model basis. Therefore, each of subdirectories <b>2032</b> includes all count data collected for a particular simulation model on a particular date. As shown in FIG. 20D, each of subdirectories <b>2032</b> is named in a fixed manner that is derived from the model name of the given model.

[0395] As further illustrated in FIG. 20D, each of subdirectories <b>2032</b> contains a corresponding one of count data storage files <b>2001</b><i>a</i>-<b>2001</b><i>n</i>, containing the count data for a specified simulation model collected on a given date. The directory/subdirectory structure contained within disk storage unit <b>2007</b> provides an efficient directory path for locating count event data for any given simulation model generated on a particular date. For example, sorting count data first by day and then by simulation model, simplifies removal of stale data from instrumentation server <b>1699</b>. Data for all active simulations models that is obtained during an expired past time interval can be removed simply by removing the appropriate subdirectory <b>2031</b> and its contents.

[0396] As a further improvement in processing counter queries, and in accordance with an important feature of the present invention, instrumentation server <b>1699</b> generates and maintains a “count event entity translation table” that is indexed on a per-design-entity basis such that all design entities contained within simulation models for which aggregate count event data has been received are listed, and are furthermore associated with a list of all of the simulation models in which they are instantiated.

[0397] To allow for the construction of the entity translation table within instrumentation server <b>1699</b>, instrumentation load tool <b>464</b> is further augmented to produce an “entitylist file” as a part of the model build process for each simulation model. The entity list file lists every design entity within a given model in which instrumentation count events are instantiated. Similar to the processing of event list files, entity list files are commissioned within instrumentation server <b>1699</b> as a part of step <b>1655</b> of FIG. 16C. Upon receiving an entity list file, instrumentation server <b>1699</b>, adds the simulation model and design entity identification contents of the entitylist file to the entity translation table.

[0398]FIG. 20E illustrates a set of exemplary entity list files <b>2041</b><i>a</i>-<b>2041</b><i>c </i>that are incorporated within a count event entity translation table <b>2044</b> in accordance with a preferred embodiment of the present invention. Each of the entitylist files <b>2041</b><i>a</i>-<b>2041</b><i>c </i>includes a list of design entity identifiers corresponding to every design entity within a respective simulation model (models X, Y, and Z) that include instantiated instrumentation count events.

[0399] Count event entity translation table <b>2044</b> maintains an index list <b>2046</b> of the design entities (a, b, c, d, x, and y) having instantiated instrumentation count events and that are included within simulation models, including models X, Y, and Z, which have been commissioned on instrumentation server <b>1699</b>. A model list <b>2045</b> includes entries corresponding to each design entity index within index list <b>2046</b> denoting those simulation models that contain the design entity designated by the design entity index entry. The steps necessary to generate count event entity translation table <b>2044</b> from entitylist files <b>2041</b><i>a</i>-<b>2041</b><i>c </i>are readily conceivable by one skilled in the art and are therefore not described herein. When a simulation model is decommissioned (i.e. records and data removed from instrumentation server <b>1699</b>), its corresponding entries within model list <b>2045</b> are removed (potentially including removal of a design entity index when the last model containing that design entity is removed) from count event entity translation table <b>2044</b>. Instrumentation server <b>1699</b>, utilizes count event entity translation table <b>2044</b> to ascertain which subset of count data storage files <b>2001</b><i>a</i>-<b>2001</b><i>n </i>must be searched in response to a user count query for a given design entity or entities.

[0400] Elements within instrumentation server <b>1699</b> utilized for storing, managing, and executing user counter queries as depicted in FIG. 20F. To create, delete, or modify counter queries, a user executes a counter query interface program <b>2050</b> on general-purpose computer <b>1600</b>. Counter query interface program <b>2050</b> utilizes a graphical user interface (GUI) <b>2051</b> on display <b>14</b> to allow the user to display, create, remove, or edit counter queries delivered to and stored within instrumentation server <b>1699</b>. A set of such counter queries <b>2053</b><i>a</i>-<b>2053</b><i>n </i>are stored on disk storage device <b>2007</b> within instrumentation server <b>1699</b>. Each of counter queries <b>2053</b><i>a</i>-<b>2053</b><i>n </i>is stored in a separate file and contains information, described below with reference to FIG. 20H, denoting the time at which the query is to be executed, the count data being requested, and the means by which to return the counter query data to the user.

[0401] A counter query manager program <b>2052</b>, residing within memory <b>44</b> of instrumentation server <b>1699</b>, executes counter queries <b>2053</b><i>a</i>-<b>2053</b><i>n </i>and also returns the final output count data to the user. At regular intervals, counter query manager <b>2052</b> examines counter queries <b>2053</b><i>a</i>-<b>2053</b><i>n </i>to determine which of these queries should be run at any given interval. A determination to run a particular counter query is made by examining information within the query itself which indicates a time at which the query is to executed within instrumentation server <b>1699</b>.

[0402] Upon determining that a specific query among counter queries <b>2053</b><i>a</i>-<b>2053</b><i>n </i>is to be executed, counter query manager <b>2052</b> spawns an instance of a counter query engine (CQE) program <b>2054</b> to process the query. Counter query manager <b>2052</b> can spawn multiple instances of counter query engine program <b>2054</b> simultaneously if multiple counter queries are to be executed over the same interval.

[0403] Counter query engine program <b>2054</b> utilizes information within the counter query and count event entity translation table <b>2044</b> in order to search appropriate count data storage files <b>2001</b><i>a</i>-<b>2001</b><i>n </i>for the counter information specified in counter query <b>2053</b>. At the end of this search, counter query program <b>2054</b> produces a query report hereinafter called a “basic counter output report”.

[0404] Referring to FIG. 20G, there is illustrated an exemplary basic counter output report <b>2060</b>. Within basic counter output report <b>2060</b>, a first integer field <b>2061</b> denotes the number of simulator cycles accumulated during simulation runs on simulation models containing the count events for which a count has been requested in the counter query. The value stored within first integer field <b>2061</b> is derived by summing count fields <b>2020</b> (FIG. 20C) for each of the counter data storage files <b>2001</b><i>a</i>-<b>2001</b><i>n </i>that contain the count events identified in the counter query. Basic counter output report <b>2060</b> further contains a report list <b>2062</b> including entries for each count event specified in the counter query. Entries within list <b>2062</b> consist of count event identifier fields <b>2063</b> and integer fields <b>2064</b> which denote the number of occurrences of a corresponding count event in accordance with information obtained from counter data storage files <b>2001</b><i>a</i>-<i>n. </i>

[0405] Counter queries can specify either a hierarchical or non-hierarchical query. In a hierarchical query, each replicated instance of any given count event is queried independently. As such, the basic counter query report lists individual entries within list <b>2062</b> for each replicated instance of a given count event. In such a circumstance, each of count event identifier fields <b>2063</b> corresponds to the extended event identifier described earlier in conjunction with FIG. 10B. Exemplary basic counter output report <b>2060</b> represents a hierarchical report for event “count1” within design entity “Z” within simulation model <b>1000</b> described earlier with reference to FIG. 10A.

[0406] Counter queries may alternatively be non-hierarchical, wherein all replicated instances of a given count event are grouped as a single event for reporting purposes. The counts for the individual instances of the count event are summed to form an overall count of the number of times the individual count event occurred in all instances.

[0407]FIG. 20G further illustrates a basic counter output report <b>2065</b> that results from a non-hierarchical counter query. Non-hierarchical basic counter output report <b>2065</b> includes an event identifier <b>2066</b> corresponding to the event identifier for the count events with the instance identifier field removed. Since the various instances of a given count event are combined into a single reported event, the instance identifier has no meaning and is not included in the non-hierarchical report.

[0408] Returning to FIG. 20F, after being produced by counter query engine <b>2054</b>, a set of basic counter output reports <b>2060</b><i>a</i>-<b>2060</b><i>n </i>is stored within instrumentation server <b>1699</b> in a subdirectory <b>2055</b>. Each report within subdirectory <b>2055</b> is named such that the date on which it was created and the particular user counter query which created the report can be determined. Basic counter output reports are stored by instrumentation server <b>1699</b> to enable on-going analysis of longer term trends of the counter data as described below.

[0409] Counter query engine <b>2054</b> may optionally be utilized for post-processing of basic counter output report <b>2060</b> in order to produce a graphical representation of the counter data such as a line plot, histogram or other such representation as a final counter query report <b>2056</b>. Each of counter queries <b>2053</b><i>a</i>-<b>2053</b><i>n </i>specifies what, if any, additional post-processing to apply to basic counter report <b>2060</b> to create final counter query report <b>2056</b>.

[0410] Final counter query report <b>2056</b> is returned to the user at general-purpose <b>1600</b> over network interface <b>1720</b> by one of a number of means that could include e-mail attachments, a specific file transfer protocol between instrumentation server <b>1699</b> and general-purpose computer <b>1600</b>, or copying the file to a shared file system among others. Each of counter queries <b>2053</b><i>a</i>-<b>2053</b><i>n </i>specifies which mechanism(s) to use in returning the data to the user (it is possible to utilize multiple methods to deliver multiple copies of final counter query report <b>2056</b>).

[0411] With reference to FIG. 20H, there is depicted a representation of the query fields within an exemplary counter query <b>2053</b>. For illustrative purposes, the fields within counter query <b>2053</b> are divided into five field groups <b>2068</b>, <b>2069</b>, <b>2081</b>, <b>2084</b>, and <b>2087</b>. Field group <b>2068</b> provides general information regarding the identity of the query and the identity of the user that initiated it. Within field group <b>2068</b>, a field <b>2071</b> contains the name of the query. Query name field <b>2071</b> provides a useful mechanism for referring to and specifying user counter queries. Also within field group <b>2068</b>, a username field <b>2072</b> contains the username identity of the user that initiated the query and field <b>2073</b> contains the name of the user machine from which the query was initiated. This information is utilized to allow counter query engine <b>2054</b> to return finished counter report <b>2056</b> to the user.

[0412] Field group <b>2069</b> generally specifies the identity of the count events to be queried in accordance with the remaining fields within counter query <b>2053</b>. Fields <b>2074</b>, <b>2075</b>, <b>2076</b>, and <b>2077</b> correspond to the instantiation, instrumentation entity, design entity, and eventname fields in the count event extended identifiers as described hereinbefore with reference to FIG. 10B. These fields, which can contain wildcard entries, are utilized to specify which instrumentation count events within a simulation model are being requested. These fields are matched by counter query engine <b>2054</b> against the count event eventlist files stored on instrumentation server <b>1699</b> to locate the desired count events within the simulation models searched during the query.

[0413] Field <b>2088</b> is an enable field (i.e. a flag) that determines whether counter query <b>2053</b> is hierarchical or non-hierarchical. If the user decides to perform a hierarchical query, instantiation identifier field <b>2074</b> is used to locate count events during the query. If, however, the query is non-hierarchical as specified by field <b>2088</b>, field <b>2074</b> is ignored in searching for count events. The extended event identifier for different instances of a given count event differ only in their instantiation identifier fields (field <b>1030</b> in FIG. 10B). By ignoring the instantiation identifier field when searching for count events, differing instances of a given count event will appear as the same count event and be merged in reporting.

[0414] Field group <b>2081</b> generally specifies the times at which to run the query and how far back in time the query should span. In a preferred embodiment, instrumentation server <b>1699</b> allows user counter queries to specify days of the week a query is to run and also to specify a particular set of hours on those days the query is run. A day field <b>2078</b> is a set of seven flags specifying which days of a week a query is to run, while an hours field <b>2079</b> is a set of <b>24</b> flags indicating the hours on those days a query is to run. Field group <b>2081</b> further includes a lookback field <b>2080</b> that specifies the how far back in time a query is to examine data. When a query is run, it searches stored counter data for the day it is run and for a number of preceding days. The number of preceding days to search is specified by field <b>2080</b>.

[0415] Field group <b>2084</b> generally specifies what, if any, report post processing is to be performed and the report delivery mechanism. A report post-process field <b>2082</b> specifies the report processing, if any to apply to produce final counter report <b>2056</b>. A report delivery field <b>2083</b> specifies which delivery mechanism(s) to utilize in returning the finished counter report to the user.

[0416] Field group <b>2087</b> generally specifies an optional restriction that limits the search of the counter data to specific models. This feature is useful to simulation teams that generally, in contrast to designers, prefer to query counter data with respect to a specific model or models, rather than querying count data at the design entity level. A simulation model search enable field <b>2086</b> holds a flag indicating whether or not counter data searches are to be limited to specific models or not. Field group <b>2087</b> also includes a models field <b>2085</b>, which may contain wildcard expressions, specifying which models the search will be conducted with respect to.

[0417] Referring to FIG. 20I in conjunction with FIG. 20H, there is shown a flowchart of the process by which counter query engine <b>2054</b> produces basic counter output report <b>2060</b> from user query <b>2053</b>. The process begins at step <b>2090</b> corresponding to counter query manager <b>2052</b> determining that query <b>2053</b> is ready to be run and spawning counter query engine <b>2054</b> to process the query.

[0418] The process continues with step <b>2091</b> depicting a determination of the possible date subdirectories <b>2031</b> (FIG. 20D) that may need to be searched. To determine these directories, counter query engine <b>2054</b> examines and compares the current date with the content of lookback field <b>2080</b> in counter query <b>2053</b>. Using this information and standard date processing techniques well known to those skilled in the art, counter query engine <b>2054</b> produces a list of directory names corresponding to the current date and the number of days before the current date specified by lookback field <b>2080</b>. These directory names correspond to date subdirectories <b>2031</b> that must be searched in accordance with counter query <b>2053</b>.

[0419] Proceeding to step <b>2092</b>, a determination is made of the model subdirectories among subdirectories <b>2032</b><i>a</i>-<b>2032</b><i>n </i>within date directories <b>2031</b> that are to be searched. Counter query engine <b>2054</b> creates a list of possible model directories by matching design entity field <b>2076</b> against index list <b>2046</b> of entity list translation table <b>2044</b> (FIG. 20E) and creating a directory list data structure (not depicted), removing duplications, of those models that correspond to matching design entities. This list represents the set of active models on instrumentation server <b>1699</b> that contain the design entity or entities specified by design entity field <b>2076</b>. In this manner, counter query engine <b>2054</b> creates a list of simulation models within the directory list data structure that are to be searched based solely on the design entity name without user intervention. The designer need not know which active models on instrumentation server <b>1699</b> contain the desired design entity or entities.

[0420] If simulation model search enable field <b>2086</b> of user query <b>2053</b> is asserted (i.e. search only with respect to designated models), the list of model subdirectories is further matched against models field <b>2085</b>. Those model subdirectories that do not match the content of model field <b>2085</b> are removed from the list generated in response to step <b>2092</b>. In this manner, the counter query is further restricted to the specific set of model names specified by field <b>2085</b>.

[0421] Next, as illustrated at step <b>2093</b>, data structures necessary to process counter query <b>2053</b> are generated. The first data structure created is a list of directory paths relative to counter storage directory <b>2030</b> (FIG. 20F) that will be searched. These directory paths are created by forming all possible combinations of the directory names obtained in steps <b>2091</b> and <b>2092</b>. It should be noted that some of the directory paths generated in this manner might not actually exist within counter storage directory <b>2030</b>. The process that generates the directory paths generates all the paths that need to be searched whether or not count event data has actually been received and stored for those models or days.

[0422] It is also possible that no directory paths match the criteria specified by query <b>2053</b>. In such a circumstance, an empty directory list data structure is generated. The second data structure generated is a basic count report data structure which is utilized to hold count events and count values found during processing. The basic count report data structure is initially empty.

[0423] The process continues at step <b>2094</b> with a determination of whether or not the directory list data structure is empty. If the directory list data structure is currently empty, the process continues at steps <b>2095</b>-<b>2097</b> where the results of the counter query are reported to the user and stored. In such a circumstance, an empty report is generated because no counter data matches the criteria specified in counter query <b>2053</b>.

[0424] If the directory list data structure is not empty, and as illustrated at step <b>2098</b>, a determination is made of whether or not the current directory in the directory list data structure exists within counter storage directory <b>2030</b>. If the directory does not exist, the process continues as depicted at step <b>2067</b> with the removal of the current directory from the directory list data structure generated at step <b>2092</b>. Processing then returns to step <b>2094</b> wherein subsequent directories in the directory list data structure are processing accordingly.

[0425] If, as determined at step <b>2098</b>, the subdirectory exists among subdirectories <b>2032</b><i>a</i>-<b>2032</b><i>n</i>, query processing continues as depicted at step <b>2099</b> with a search of the simulation model for count events corresponding to those specified by counter query <b>2053</b>. To locate count events corresponding to counter query <b>2053</b>, counter query engine <b>2054</b> matches fields <b>2074</b>, <b>2075</b>, <b>2076</b>, and <b>2077</b> against the extended event identifiers in the count eventlist file for the simulation model whose data is stored in the identified one of subdirectories <b>2032</b><i>a</i>-<b>2032</b><i>n</i>. The names and indices of matching count events are determined to allow for subsequent retrieval of the counter value from a corresponding one of counter data storage files <b>2001</b><i>a</i>-<b>2001</b><i>n. </i>

[0426] Proceeding to step <b>2009</b>, matching count events are used to update the basic count report data structure. If a matching count event discovered in step <b>2099</b> is not present in the basic count data structure, the count event is added to basic count data structure using the count value found in the corresponding one of count data storage files <b>2001</b><i>a</i>-<b>2001</b><i>n</i>. Otherwise, the count value found in count data storage file <b>2001</b> is added to the count event entry already present in the basic count report data structure. This produces a cumulative total for the number of times the count event has occurred in the simulation models specified by counter query <b>2053</b>.

[0427] The counter query process continues at steps <b>2067</b> and <b>2094</b> wherein the directory is removed from the directory list data structure and a determination is made of whether or not any further subdirectories remain to be searched. If no unsearched subdirectories remain, the process continues at step <b>2095</b> which depicts storing the basic counter report in directory <b>2055</b> on instrumentation server <b>1699</b> as previously described.

[0428] Next, as illustrated at step <b>2096</b>, final counter report <b>2056</b> is generated utilizing the post-processing mechanism selected by field <b>2082</b> of counter query <b>2053</b>. The process is completed as depicted at step <b>2097</b> with final counter report <b>2056</b> being delivered to the user by the means selected by field <b>2083</b> of counter query <b>2053</b>.

[0429] The mechanisms described above provide a means of creating, managing and executing counter queries that allows a designer to access counter data without specific knowledge of which hardware simulation models within batch simulation farm <b>1601</b> contain the desired design entity or entities. Furthermore, by accessing and storing count data by a parameter known to the designers, namely the design entities containing the count event, the above described mechanisms provide a simple interface to access count data based solely on items known to designers as part of the creation of count events. In addition, the means described above provides for counter queries to be repeated and count data to be returned at regular intervals without specific intervention from designers. In this manner, designers can provide on-going evaluation of count data without the burden of specific intervention to maintain the execution of queries.

[0430] In addition to obtaining design entity centric counter results, it would further be advantageous to provide a means of determining trends in counter instrumentation data within a batch simulation farm environment. In particular, it would be useful to determine differences in rates of occurrence of count events, scaling appropriately for the number of simulation cycles executed, as simulation of one or more simulation models, including instantiated instances of the count events, progresses over time.

[0431] To this end, and in accordance with an important feature of the present invention, instrumentation server <b>1699</b> implements a reporting mechanism that compares independently collected sets of count event data for count events specified by a given user query and produces a report showing differences with respect to a predetermined threshold level, among the independently collected sets. This reporting mechanism will hereinafter be referred to as a “count difference analyzer”.

[0432] As implemented in accordance with the embodiments depicted herein, the count difference analyzer accepts as processing inputs either two basic counter output reports, similar in structure to basic counter output report <b>2060</b>, or two count data storage files among count data storage files <b>2001</b><i>a</i>-<b>2001</b><i>n</i>, and returns a count difference report. By comparing basic counter output reports, the count difference analyzer of the present invention determines changes in count results for instrumentation count events present within the basic counter reports. The count difference analyzer described herein is particularly useful to circuit designers to monitor instrumentation count event trends for count events specified within a particular design entity or simulation model.

[0433] When performing relative comparisons between count data within count data storage files <b>2001</b><i>a</i>-<b>2001</b><i>n</i>, the count difference analyzer of the present invention provides an efficient means of count trend analysis for all count events instantiated within an entire simulation model. This feature is particularly useful to simulation users whose primary interest is directed toward simulation results for simulation models as a whole.

[0434] Elements and processing steps required to implement a count difference analyzer within instrumentation server <b>1699</b> are depicted in FIGS. <b>21</b>A-<b>21</b>D. FIG. 21A depicts a system applicable within a batch simulation farm for storing and accessing trends in count event data in accordance with a preferred embodiment of the present invention and FIG. 21C is a high-level flow diagram depicting steps performed within a batch simulation farm instrumentation server during count difference analysis performed within the system shown in FIG. 21A. The count difference analysis process within the system depicted in FIG. 21A begins as illustrated at step <b>2102</b> of FIG. 21C.

[0435] In accordance with the system illustrated in FIG. 21A, counter query manager <b>2052</b> includes program instructions (not depicted) to spawn instances of a count difference analyzer engine (CDAE) <b>2100</b>. CDAE <b>2100</b> is a set of program instructions resident within memory <b>44</b> of instrumentation server <b>1699</b> that is spawned under two general conditions. The first of these conditions occurs, as depicted at step <b>2104</b> of FIG. 21C, in accordance with the status of an additional flag field that is added to counter query <b>2053</b> (not depicted in FIG. 20H), which if asserted, initiates a count difference analysis to be performed in conjunction with counter query <b>2053</b>. When this enable flag is asserted, counter query manager <b>2052</b> spawns CDAE <b>2100</b> at the conclusion of counter query processing as described hereinabove with reference to FIGS. <b>20</b>A-<b>201</b>.

[0436] As depicted at step <b>2120</b>, CDAE <b>2100</b> compares the current most recently created basic counter output report <b>2060</b><i>b </i>with the basic counter output report <b>2060</b><i>a </i>resulting from the previously most recently executed version the same counter query to produce a counter difference report <b>2105</b><i>a </i>(step <b>2122</b>). As explained in further detail with reference to FIG. 21D, counter difference report <b>2105</b><i>a </i>contains information indicating any relative changes in occurrences of one or more queried count events in accordance with disparities between basic counter output reports <b>2060</b><i>a </i>and <b>2060</b><i>b</i>. A final counter difference report <b>2106</b> is delivered to the user by the same means as those selected within report delivery field <b>2083</b> of query counter <b>2053</b> (FIG. 20H) for final query counter report <b>2056</b> (FIG. 20F).

[0437] As illustrated at step <b>2106</b> of FIG. 21C, a second condition under which counter query manager <b>2052</b> spawns an instance of CDAE <b>2100</b> is at the expiration of the predetermined counter query interval (e.g. at the end of each day) for every simulation model that has received counter data for that day. As shown at step <b>2108</b> at a pre-specified counter query interval, CDAE <b>2100</b> compares counter data storage files <b>2001</b><i>a </i>and <b>2001</b><i>b </i>(possibly after conversion of the respective count data storage files into basic output counter report format) to produce a counter difference report <b>2105</b><i>b </i>(step <b>2122</b>). In accordance with the embodiment depicted in FIG. 21A, counter data storage files <b>2001</b><i>a </i>and <b>2001</b><i>b </i>constitute the counter data for a particular simulation model over sequential time intervals (current and previous day, for example). Counter difference report <b>2105</b><i>b </i>therefore includes data relating to the relative changes in count event occurrences for all count events in the given simulation model between the two days.

[0438] Counter difference reports for commissioned simulation models are stored by instrumentation server <b>1699</b> and are accessible by users via a graphical user interface <b>2107</b> that communicates with counter query manager <b>2052</b>. It should be noted that counter difference reports not initiated by a counter query (i.e. those initiated in accordance with step <b>2106</b>) do not have a specified return destination. However, instrumentation server <b>1699</b> also provides a means, not described here in detail, that allows interested users to obtain counter difference reports for a certain model or models delivered in a manner similar to that used to deliver final counter reports. The count difference analysis process terminates as depicted at step <b>2124</b> of FIG. 21C.

[0439] With reference to FIG. 21B in conjunction with FIG. 21D, there are illustrated a system and a process for performing count difference analysis in accordance with a preferred embodiment of the present invention. The steps depicted in FIG. 21D provide a more detailed description of comparison and report generation steps <b>2120</b>, <b>2108</b>, and <b>2122</b> of FIG. 21C.

[0440] The count difference analysis system illustrated in FIG. 21B includes CDAE <b>2100</b> receiving inputs from a pair of basic counter output reports <b>2110</b><i>a </i>and <b>2110</b><i>b </i>for a given non-hierarchical counter query. A resultant count difference report <b>2115</b> is generated by CDAE <b>2100</b> in accordance with the process step described herein. As further depicted in FIG. 21B, basic counter output reports <b>2110</b><i>a </i>and <b>2110</b><i>b </i>include individual row-wise entries corresponding uniquely to a particular instrumentation count event. Basic counter output report <b>2110</b><i>a </i>provides count totals within count fields <b>2112</b><i>a </i>for count events count1, count2, count3, count4, and count5, for simulation testcases performed over 9000 simulation cycles as indicated within a cycle count field <b>2111</b><i>a. </i>Likewise, basic count report <b>2110</b><i>b </i>provides count totals within count fields <b>2112</b><i>b </i>for count events count1, count2, count3, count4, and count6, for simulation testcases performed over 18000 simulation cycles as indicated within a cycle count field <b>2111</b><i>b. </i>

[0441] The count difference analysis depicted in FIG. 21D begins at step <b>2126</b> and continues with a normalization factor computation as shown at step <b>2128</b>. The normalization factor computation depicted at step <b>2128</b> is performed by CDAE <b>2100</b> to normalize the count event count values within count fields <b>2112</b><i>a </i>and <b>2112</b><i>b </i>to account for any difference in the respective number of simulation cycles (9000 and 18000, respectively) over which the results of basic counter output reports <b>2110</b><i>a </i>and <b>2110</b><i>b </i>were obtained.

[0442] To normalize the count event values within count fields <b>2112</b><i>a </i>and <b>2112</b><i>b</i>, CDAE <b>2100</b> computes a ratio between cycle count fields <b>2111</b><i>b </i>and <b>2111</b><i>a </i>and then multiplies the count values within count fields <b>2112</b><i>a </i>by this ratio. In the depicted embodiment, such normalization entails multiplying each of the count values constituting count fields <b>2112</b><i>a </i>by the ratio (18000/9000) before further processing.

[0443] Once the count values are normalized, CDAE <b>2100</b> determines the differences between the normalized count values. To this end, and as illustrated at step <b>2130</b> of FIG. 21D, CDAE <b>2100</b> first determines those count events that have either been added or removed in their entirety to or from basic count report <b>2110</b><i>a </i>and <b>2110</b><i>b </i>(i.e. appear in only one of basic counter reports <b>2110</b><i>a </i>or <b>2110</b><i>b</i>). Such added or removed count events are reported in an event disparity report field <b>2113</b> of count difference report <b>2115</b> (step <b>2132</b>) and are removed from further counter difference analysis processing.

[0444] Following the removal of data for count events that have been newly added or removed and for which a trend analysis is thus currently impracticable, CDAE <b>2100</b> identifies which of the remaining count events that have a count value of zero as reported in either of basic counter output reports <b>2110</b><i>a </i>or <b>2210</b><i>b </i>(step <b>2134</b>). Such zero-value count events correspond to counts events that were present (i.e. not removed or added) within the design entities targeted by the counter queries from which both basic counter output reports <b>2110</b><i>a </i>and <b>2110</b><i>b </i>were produced, but which have either just started occurring as reported in basic counter output report <b>2110</b><i>b</i>, or have occurred as reported in basic counter output report <b>2110</b><i>a </i>but not over the reporting interval of basic counter output report <b>2110</b><i>b</i>. Such zero-value count events are reported in a zero count event field <b>2114</b> of counter difference report <b>2115</b> as depicted at step <b>2136</b> of FIG. 21D. As with the added or removed count events recorded in event disparity field <b>2114</b>, the identified zero-value count events are immaterial to trend analysis and are not further considered in the present counter difference analysis.

[0445] For remaining count events, which have non-zero count values and are not newly added or removed, CDAE <b>2100</b> computes the percentage increase or decrease in occurrence between corresponding count events results contained in basic counter output reports <b>2110</b><i>b </i>and <b>2110</b><i>a </i>as illustrated at step <b>2138</b>. As depicted at steps <b>2140</b> and <b>2142</b>, those count events whose percentage change exceeds a predetermined threshold value (for example, plus or minus 20 percent in counter difference report <b>2115</b>), are reported in a threshold exceeded field <b>2116</b> within counter difference report <b>2115</b> and are not further considered by CDAE <b>2100</b>. The percentage change threshold value can be specified by the user for each query.

[0446] The remaining count events in count reports <b>2110</b><i>a </i>and <b>2110</b><i>b</i>, which have neither been added/removed nor exceeded the percentage change threshold value constitute those count events whose count values, after scaling, are within the specified percentage change threshold and are not reported in counter difference report <b>2115</b>.

[0447] In the foregoing description of FIGS. 21A and 21B, the functionality of CDAE <b>2100</b> has been described with respect to basic counter query output reports. For cases in which CDAE <b>2100</b> must process counter data storage files <b>2001</b><i>a</i>-<b>2001</b><i>n </i>(as when comparing count data for an entire simulation model) these counter data storage files are first converted to basic counter reports prior to commencing processing by CDAE <b>2100</b>.

[0448] In accordance with a preferred embodiment of the present invention, a counter data storage file is converted to a basic counter report by placing its cycle count field <b>2020</b> (FIG. 20C) value into cycle count integer field <b>2061</b> (FIG. 20G) of the basic counter output report. Furthermore the count event list file for the object simulation model is utilized to generate count event identifier fields <b>2063</b> (FIG. 20G) of the basic count report. Finally, cumulative count values fields <b>2021</b><i>a</i>-<b>2021</b><i>n </i>(FIG. 20C) of the counter data storage file are utilized to generate corresponding count value fields <b>2064</b> (FIG. 20G) within the resultant basic counter output report. In this manner, count data storage files <b>2001</b><i>a</i>-<b>2001</b><i>n </i>can be converted to basic counter reports of the form depicted in FIG. 20G suitable for processing by CDAE <b>2100</b>.

[0449] With respect to FIGS. <b>21</b>A-<b>21</b>D, the functionality of CDAE <b>2100</b> was described in terms of comparing count data storage files that contained count data obtained on consecutive days or comparing basic counter output reports obtained from sequential executions of a given user counter query. The extensions necessary for CDAE <b>2100</b> to compare count data storage files obtained on non-consecutive days (separated by a week, for example) or to compare basic counter output reports obtained from non-sequential executions of a given counter query would be obvious to one skilled in the art and are included within the scope and spirit of the present invention. Furthermore, the present inventive concept encompasses situations in which count data storage files containing count data obtained over time intervals other than days (weeks, for example), which could similarly be combined into two count data storage files and compared by CDAE <b>2001</b>. Similar techniques could be applied to combine basic count reports <b>2060</b> to produce reports spanning longer periods of time that can be compared. In this manner, different time periods can be analyzed by CDAE <b>2100</b> to determine longer-term trends in counter instrumentation data. The above-described process provides a means to analyze and report on longer term trends in counter instrumentation data. This technique provides for automatic on-going analysis of counter instrumentation data for both user counter query reports and for simulation models as a whole.

[0450] In a batch simulation farm environment, it would further be advantageous to provide a means to collect and store, with minimal redundancy, those testcases in which harvest events, occur. In accordance with the embodiments depicted herein, testcases in which harvest events occur are stored on a per simulation model basis, thus providing a collection of testcases for the given simulation model that trigger the harvest events incorporated within the instrumentation associated with the simulation model. Each collection of such harvest event triggering testcases are referred to herein as a “harvest testcase bucket” and are stored on a designated “harvest testcase server”. Similar to a failed testcase server, the harvest testcase server serves as a repository for testcases collected in response to the occurrence of a harvest instrumentation event during execution of said testcases during simulation of said simulation model.

[0451] The foregoing description of count and fail event processing did not account for multiple testcases being executed within a given simulation run. In practice, however, multiple testcases are executed during a given simulation job in order to amortize the overhead of processing a simulation job over multiple testcases. When processing multiple testcases during a simulation job, the simulation model is reset at the conclusion of a testcase before the execution of the subsequent testcase.

[0452] For count and fail events, resetting the simulation model includes a mere reset of the event result registers between testcases. Therefore, between each testcase within a simulation job, counters <b>421</b> (FIG. 4B) are reset to a value of zero and fail flags <b>424</b> (FIG. 4B) are cleared. The simple resetting of count and fail event results following each testcase is permissible as a consequence of the fact that the practical significance of count and fail events may attach to, but does not extend beyond, the particular testcase in which they occur. This is in contrast to harvest events, whose significance lies simply in the conditions arising during any testcase that triggers the harvest event during simulation of a given simulation model.

[0453] Due to this singularity of significance of harvest events, it is desirable to minimize redundancy in the collection of testcases in which a given harvest event occurs during multi-testcase processing of a simulation model. The present invention provides a mechanism by which the processing of subsequent harvest-event-triggering testcases is influenced by previously recorded harvest events that have occurred in previous testcases to prevent potentially extensive redundant harvest testcase collection in the harvest testcase bucket.

[0454]FIG. 22A illustrates elements within batch simulation farm <b>1601</b> utilized in collecting harvest event testcases in accordance with a preferred embodiment of the present invention. FIG. 22A illustrates the contents of memory <b>44</b> within simulation client <b>1701</b> during the execution of the testcases within a simulation job. Prior to execution of the first testcase within a simulationjob, RTX <b>1702</b>, as part of step <b>1638</b> of FIG. 16D, calls an API entry point init_harv( ) <b>2200</b>. API entry point <b>2200</b> is a routine that communicates with instrumentation server <b>1699</b> and/or shared file system <b>1609</b> to obtain a list of harvest events from a “harvest hit table”, which have already occurred during simulation testing of simulation model <b>1700</b>. A separate, initially empty harvest hit table is stored for each commissioned simulation model within instrumentation server <b>1699</b>.

[0455] In response to obtaining a network copy of the harvest hit table for the current model, API entry point <b>2200</b> initializes a local harvest table <b>2201</b> within simulator <b>1735</b>. Local harvest hit table <b>2201</b> initially includes a list of harvest event names that, as evidenced by their inclusion within the harvest hit table referenced by API entry point <b>2200</b>, have already occurred during simulation testing of simulation model <b>1700</b>.

[0456] In a manner analogous to that described with respect to API entry point disable_events( ) <b>1800</b> in FIG. 18B, API entry point init_harv( ) <b>2200</b> obtains a copy of the harvest hit table from one of two network sources. The first source is a master harvest hit table <b>2205</b> stored on disk within instrumentation server <b>1699</b>. The second possible source is an auxiliary harvest hit table <b>2207</b> that is stored in association with general-purpose computer <b>1607</b> in shared file system <b>1609</b>. Master harvest hit table <b>2205</b> serves as the primary (i.e. most currently updated) version of the harvest hit table. At regular intervals, instrumentation server <b>1699</b> copies the contents of master harvest hit table <b>2205</b> into auxiliary harvest hit table <b>2207</b>, which serves as a backup copy of the harvest hit table.

[0457] The two-file system depicted in FIG. 22A is used to maintain the harvest hit table in a flexible and robust manner within geographically distributed batch simulation farm <b>1601</b> for reasons similar to those discussed above in connection with FIG. 18A. Simulation clients that obtain the harvest hit table from shared file system <b>1609</b> can potentially receive a “stale” copy of the harvest hit table. Although this problem may be minimized by copying master file <b>2205</b> onto auxiliary file <b>2207</b> on a regular interval to quickly resolve any discrepancies between master file <b>2205</b> and auxiliary file <b>2207</b>, harvest testcase processing based on a stale harvest hit table may result in redundancy within the harvest testcase bucket. The undesirability of such redundancy may, however, be outweighed by the additional robustness gained by storing the harvest hit table at different network locations. The present invention includes techniques for removing redundant testcases stored as a result of a stale harvest hit table, along with other sources of inconsistency, as described in further detail below.

[0458] After calling API entry point <b>2200</b>, RTX <b>1702</b> executes the first testcase within the simulation job. Once the testcase completes execution, and as part of step <b>1637</b> of FIG. 16D, RTX <b>1702</b> calls an API entry point rpt_harv( ) <b>2202</b>, which first examines harvest flags <b>423</b><i>a</i>-<b>423</b><i>n </i>(FIG. 4B) to determine which harvest events, if any, have been triggered by the testcase. API entry point <b>2202</b> then compares the harvest event occurrences as recorded by the status of harvest flags <b>423</b><i>a</i>-<b>423</b><i>n </i>with the content of local harvest hit table <b>2201</b> to determine if any preliminarily non-redundant harvest events (i.e. harvest events triggered during the testcase that do not match those recorded in local harvest hit table <b>2201</b>) have occurred. In the absence of any preliminarily non-redundant harvest events (i.e. all harvest events triggered during the testcase match those recorded in local harvest hit table <b>2201</b>), API entry point <b>2202</b> terminates processing and returns to RTX <b>1702</b> an indication directing RTX <b>1702</b> not to copy the current testcase into a harvest testcase bucket <b>2300</b>. By referring to local harvest hit table <b>2201</b>, API entry point <b>2202</b> prevents unnecessary communication with instrumentation server <b>1699</b> in those cases in which the harvest events that were triggered by the current testcase have already been collected during previous simulations of simulation model <b>1700</b> within batch simulation farm <b>1601</b>.

[0459] If, however, one or more preliminarily non-redundant harvest events have occurred (i.e. at least one harvest event triggered by the testcase does not match any harvest event recorded in local harvest hit table <b>2201</b>), API entry point <b>2202</b> continues operation in one of two alternative modes (described in further detail below) to potentially further validate the non-redundant status of the harvest event(s) in question. As explained in further detail below, a “direct mode” or an “indirect mode” of further non-redundant status inquiry may be pursued by API entry point <b>2202</b>. The direct non-redundant status inquiry is designed to ensure that only one testcase per harvest event is delivered from a given simulation client for storage within harvest testcase bucket <b>2300</b>. The indirect mode of non-redundant status inquiry results in the possibility that some redundant testcases (i.e. testcases triggering the same harvest event) will be delivered from simulation client <b>1701</b> to harvest testcase bucket <b>2300</b>.

[0460] It should be noted that a preliminarily non-redundant harvest event, as recorded within local harvest hit table <b>2201</b>, may in fact be redundant with respect to interim testcase activity within batch simulation farm <b>1601</b>. In the time interval between the initialization of local harvest hit table <b>2201</b> and the completion of the object testcase, another simulation client may detect and record the occurrence of one or more of the preliminarily non-redundant harvest events detected by simulator <b>1735</b>. In this case, harvest events appearing to be new in accordance with local harvest hit table <b>2201</b>, have actually already occurred during another testcase. In accordance with a preferred embodiment of the present invention, API entry point rpt_hrv( ) <b>2202</b> may undertake additional processing steps to ensure that an apparently newly occurring harvest event has not actually occurred elsewhere within batch simulation farm <b>1601</b>.

[0461] In the direct mode of non-redundancy status inquiry, API entry point <b>2202</b> opens a direct network connection (e.g. Unix socket connection) on network <b>1720</b> to a harvest manager program <b>2215</b>, which executes on instrumentation server <b>1699</b>. Over this direct network connection, API entry point rpt_hrv( ) <b>2202</b> delivers an aggregate instrumentation data packet consisting of the contents of harvest cycle counters <b>422</b><i>a</i>-<b>422</b><i>n</i>, harvest flags <b>423</b><i>a</i>-<b>423</b><i>n</i>, and the name of the current testcase.

[0462] Harvest manager program <b>2215</b> first verifies that the aggregate instrumentation data packet is associated with a simulation model commissioned within instrumentation server <b>1699</b> in accordance with the means described with respect to FIGS. <b>17</b>A-<b>17</b>C. Following packet commissioning verification, harvest manager program <b>2215</b> then compares the contents of master harvest hit table <b>2205</b> with the contents of the received aggregate instrumentation data packet to determine if any preliminarily non-redundant harvest event occurrences are recorded in the master harvest hit table <b>2205</b>.

[0463] Any of the apparently new harvest events that are not currently recorded in master harvest hit table <b>2205</b>, are recorded by harvest manager program <b>2215</b> in master harvest hit table <b>2205</b> in association with the name of the current testcase. If multiple new harvest events have occurred in the current testcase, each of these events is recorded as having been triggered by the current testcase. In this manner, it is possible to determine which specific harvest events have been triggered by each testcase within harvest testcase bucket <b>2300</b>. Subsequent to detecting and recording newly occurring harvest events in master harvest hit table <b>2205</b>, harvest manager program <b>2215</b> returns an indication, over the direct network connection on network <b>1720</b>, to API entry point <b>2202</b> to deliver a copy of the current testcase to harvest testcase bucket <b>2300</b>.

[0464] In the case that all of the apparently new harvest events (i.e. all harvest events triggered during the current testcase having no corresponding entry in local harvest hit table <b>2201</b>) are currently recorded in master harvest hit table <b>2205</b>, harvest manager program <b>2215</b> returns an indication to API entry point <b>2202</b> over the direct network connection on network <b>1720</b>, directing API entry point <b>2202</b> not to deliver a copy of the current testcase.

[0465] In accordance with an important feature of the depicted embodiment, only one simulation client may have an active network connection with harvest manager <b>2215</b> at any given time. Prior to obtaining a communicative connection with harvest manager program <b>2215</b>, other simulation clients attempting to validate the redundancy status of harvest events must wait until harvest manager program <b>2215</b> has first completed processing a current connection, and second has performed any necessary updates to master harvest hit table <b>2205</b>.

[0466] In this manner, updates to master harvest hit table <b>2205</b> are serialized, thereby preventing the collection of redundant testcases for any given harvest event. Therefore, in direct non-redundancy verification mode, once a testcase is collected within harvest testcase bucket <b>2300</b> in association with the recordation of a given harvest event in master harvest hit table <b>2205</b>, no further testcases will be collected in association with the same harvest event.

[0467] While direct non-redundancy verification mode prevents the collection of multiple, effectively redundant testcases for a given harvest event, it can potentially be error prone and costly in practice. The direct network connection between simulation client <b>1701</b> and instrumentation server <b>1699</b> maybe costly to establish, subject to errors in high network traffic conditions, and serves only one simulation client at a time. These issues are especially relevant for simulation clients residing in geographically distant nodes. In such circumstances, it maybe preferable to permit a certain level of redundancy in harvest testcase bucket <b>2300</b> in order to reduce the processing and communication overhead required for direct non-redundancy inquiries.

[0468] To this end, an indirect non-redundancy verification inquiry is utilized wherein API entry point <b>2202</b> uses only local harvest hit table <b>2201</b> in determining whether or not to collect a testcase. In indirect non-redundancy verification, API entry point rpt_hrv( ) <b>2202</b> bypasses the step of further validating an apparently new harvest event with harvest manager <b>2215</b>. Communication overhead associated with a direct network connection with harvest manager program <b>2215</b> is thus reduced at the cost of potential redundancy in harvest testcase bucket <b>2300</b>.

[0469] In indirect harvest mode, when, in accordance with the content of local harvest hit table <b>2201</b>, an apparently new harvest event has been triggered by a current testcase, API entry point <b>2202</b> prepares an aggregate instrumentation data packet containing the contents of harvest cycle counters <b>422</b><i>a</i>-<b>422</b><i>n</i>, harvest flags <b>423</b><i>a</i>-<b>423</b><i>n</i>, and the name of the current testcase.

[0470] This aggregate instrumentation data packet is delivered to instrumentation server <b>1699</b> over network <b>1720</b> utilizing a non-direct network connection. Such a non-direct network connection may be established via several well-known communications mechanisms such as custom file transfer or messaging protocols. This communication mechanism accepts the aggregate instrumentation data packet for delivery and subsequently returns control to API entry point <b>2202</b>. The aggregate instrumentation data packet is then delivered to harvest manager program <b>2215</b> at a later time independent of the subsequent execution of API entry point <b>2202</b> or RTX <b>1702</b>. This communication mechanism allows multiple simulation clients to be served simultaneously in a batch fashion, and does not require a direct network connection per simulation client to be established for harvest manager program <b>2215</b>.

[0471] This is in contrast to the communication means utilized during a direct non-redundancy verification inquiry, wherein API entry point <b>2202</b> cannot return control to RTX <b>1702</b> until the aggregate instrumentation packet has been delivered to instrumentation server <b>1699</b>, processing of the packet has been completed, and an indication has been returned by harvest manager program <b>2215</b> of whether or not to copy the current testcase to harvest testcase bucket <b>2300</b>. Simulation clients must sequentially execute these collective steps to gain access to instrumentation server <b>1699</b>. This can lead to bottlenecks in performance in heavy network load situations, especially in large geographically distributed batch simulation farms.

[0472] When harvest manager program <b>2215</b> receives an aggregate instrumentation data packet from a simulation client operating in indirect non-redundancy verification mode, the commissioning status of the aggregate data packet is first validated according to the means described above in conjunction with FIGS. <b>17</b>A-C. The contents of the aggregate data packet are compared to master harvest hit table <b>2205</b> in a manner analogous to that utilized in direct harvest mode. Any harvest events recorded in the aggregate instrumentation data packet that are not currently included within master harvest hit table <b>2205</b> are identified and recorded in master harvest hit table <b>2205</b>. If all harvest events present in the aggregate instrumentation data packet are already recorded in master harvest hit table <b>2205</b>, the aggregate instrumentation data packet is discarded.

[0473] As in direct non-redundancy verification mode, in indirect harvest mode, harvest manager program <b>2215</b> must processes aggregate instrumentation data packets received from clients in a serial fashion. In this manner, accesses to master harvest hit table <b>2205</b> for simulation clients utilizing indirect non-redundancy verification mode are also serialized and only one testcase is recorded in master harvest hit table <b>2205</b> as having triggered each harvest event.

[0474] However, in indirect non-redundancy verification mode, it is possible for multiple testcases to be delivered from simulation clients to harvest testcase bucket <b>2300</b> for the same harvest event. As one example, two simulation clients may receive the same harvest hit table content from the init_harv( ) call by API entry point <b>2200</b>. These simulation clients then independently execute differing testcases that both trigger the same, preliminarily non-redundant (in accordance with their respective local harvest hit tables) harvest event. In both simulation clients, API entry point rpt_hrv( ) <b>2202</b> will instruct RTX <b>1702</b> to harvest their respective testcases.

[0475] Furthermore, aggregate instrumentation data packets for both testcases will be delivered to harvest data manager program <b>2215</b>. The aggregate instrumentation data packet received first will be recorded in master harvest hit table <b>2205</b>. The subsequently received aggregate instrumentation data packet will be ignored due to the fact that the object harvest event has already been recorded in master harvest hit table <b>2205</b>. In this situation, the testcase reported by the simulation client producing the second aggregate instrumentation data packet is redundantly stored within harvest testcase bucket <b>2300</b>. As explained in further detail with reference to FIGS. <b>23</b>A-<b>23</b>C, the present invention provides techniques for removing these redundant testcases from the harvest testcase bucket <b>2300</b>.

[0476] In a preferred embodiment, harvest manager program <b>2215</b> is configured to simultaneously process aggregate instrumentation data packets from simulation clients operating in either direct or indirect non-redundancy verification mode. Therefore, simulation clients within a batch simulation farm may operate in either direct or indirect harvest mode, according to which mode is most advantageous.

[0477] As a next step in processing in either direct or indirect mode, API entry point <b>2202</b> updates local harvest hit table <b>2201</b> to record those harvest events that were triggered by the current testcase. In this manner, subsequent testcases within the simulation job will be prevented from potentially erroneously harvesting another testcase for a harvest event that has already occurred.

[0478] As an additional optional additional processing step available in either direct or indirect harvest mode, API entry point <b>2202</b> may also communicate with instrumentation server <b>1699</b> and/or shared file system <b>1609</b> to obtain an updated copy of the harvest hit table. Typically, this data is obtained from shared file system <b>1609</b> to reduce the communication load on instrumentation server <b>1699</b>.

[0479] The harvest hit table information is used to further update local harvest hit table <b>2201</b> with a more current image of those harvest events that have been detected and recorded during simulation jobs executing on other simulation clients. In this manner, the processing of harvest events by simulation client <b>1701</b> is influenced by harvest events already harvested by other simulation clients since the last update of local harvest hit table <b>2201</b>, and unnecessary network communication is avoided while processing subsequent testcases that hit harvest events captured by other simulation clients. This additional processing step is most advantageous in circumstances in which testcases take a long period of time to complete, and therefore many additional harvest events may have been detected and recorded in parallel on other simulation clients.

[0480] Following data packet processing by harvest manager program <b>2215</b>, API routine <b>2202</b> returns an indication, received either directly from harvest manager program <b>2215</b> in direct mode or by an examination of data structure <b>2201</b> in indirect mode, to RTX <b>1702</b> of whether or not the current testcase is to be copied to harvest testcase bucket <b>2300</b>. Upon receiving an indication to save the current testcase from API entry point <b>2202</b>, RTX <b>1702</b> delivers a copy of current testcase to harvest testcase server <b>2210</b>.

[0481] Each of a set of harvested testcases <b>2213</b><i>a</i>-<b>2213</b><i>n </i>is stored in association with a particular simulation model on a disk storage device <b>2211</b> associated with harvest testcase server <b>2210</b>. Harvest testcase server <b>2210</b> also maintains a harvested testcase list <b>2214</b> that includes the name of each testcase within harvest testcase bucket <b>2300</b>. Harvested testcase list <b>2214</b> is updated whenever a new testcase is stored to provide an up-to-date list of the testcase names for the harvest testcases stored for the given simulation model.

[0482] It should be noted that certain errors can occur that prevent RTX <b>1702</b> from successfully storing the current testcase on harvest testcase server <b>2210</b>. However, when such an error occurs in direct non-redundancy verification mode, master harvest hit table <b>2205</b> has already been updated to indicate that the current testcase has been collected. Similarly, in indirect mode, master harvest hit table <b>2205</b> has been or will be similarly updated (barring errors in processing the aggregate instrumentation data packet sent to instrumentation server <b>1699</b> during step <b>2256</b> of FIG. 22B). Such failures to store the testcase can cause an inconsistency between master harvest hit table <b>2205</b> and harvest testcase bucket <b>2300</b> stored on instrumentation server <b>2210</b>.

[0483] After the testcase has been harvested if necessary, RTX <b>1702</b> calls API entry point clr_harv( ) <b>2203</b>. API entry point <b>2203</b> clears harvest flags <b>423</b><i>a</i>-<b>423</b><i>n </i>in preparation to run a subsequent testcase. RTX <b>1702</b> then executes the next testcase within the simulation job, repeating the harvest testcase verification and collection process until all testcases within the simulation job have been completed.

[0484]FIG. 22B is a flow diagram depicting in greater detail the operation of API entry point <b>2202</b> in accordance with a preferred embodiment of the present invention. API entry point <b>2202</b> begins execution at step <b>2250</b> upon being called by RTX <b>1702</b>. The process continues at step <b>2251</b> which depicts a comparison between the contents of harvest flags <b>423</b><i>a</i>-<b>423</b><i>n </i>with the content of local harvest hit table <b>2201</b> to determine if any apparently new harvest events have been triggered by the current testcase (step <b>2252</b>).

[0485] If, in accordance with the comparison shown at step <b>2251</b>, no apparently new harvest events have occurred, the process continues as illustrated at step <b>2258</b>, with the setting of an internal indication instructing RTX <b>1702</b> not to harvest the current testcase. Otherwise, as depicted at step <b>2253</b>, an aggregate instrumentation data packet is generated containing the contents of harvest cycle counters <b>422</b><i>a</i>-<b>422</b><i>n</i>, harvest flags <b>423</b><i>a</i>-<b>423</b><i>n</i>, and the name of the current testcase.

[0486] Proceeding to step <b>2254</b>, wherein is depicted a determination of whether non-redundancy verification is to be performed in direct or indirect mode. If indirect mode is selected, and as illustrated at step <b>2256</b>, the aggregate instrumentation packet generated in step <b>2253</b> is scheduled for a later delivery to harvest manager program <b>2215</b>. If direct non-redundancy verification processing is selected by the simulation client, API routine rpt_hrv( ) <b>2202</b> continues as shown at step <b>2255</b>, by delivering the aggregate instrumentation data packet to harvest manager program <b>2215</b> via a direct network connection over network <b>1720</b> to validate the first occurrence status of the apparently new harvest events (step <b>2257</b>).

[0487] As part of step <b>2257</b> a determination is returned to API entry point <b>2202</b> from harvest manager program <b>2215</b> of whether the harvest events are actually new. If the harvest events are not new (i.e. are recorded in the current network harvest hit table), the process continues as depicted at step <b>2258</b>, with API entry point <b>2202</b> setting an internal indication instructing RTX <b>1702</b> not to copy the current testcase to harvest testcase bucket <b>2300</b>. If, as determined by the comparison of aggregate instrumentation packet data with the network harvest hit table, the harvest events are actually new, API entry point <b>2202</b> sets an internal indication instructing RTX <b>1702</b> to copy and deliver the current testcase to harvest testcase bucket <b>2300</b> (step <b>2259</b>).

[0488] API entry point <b>2202</b> processing continues at step <b>2260</b>, with an update of local harvest hit table <b>2201</b> to include those harvest events that have occurred in the current testcase. Continuing at step <b>2261</b>, a determination is made of whether or not local harvest hit table <b>2201</b> should be updated to reflect those harvest events captured by other simulation clients. If the optional update is selected, API routine <b>2202</b> requests an updated image of the harvest hit table from either instrumentation server <b>1699</b> and/or shared file system <b>1609</b> as illustrated at step <b>2263</b>. Next, as depicted at step <b>2264</b> local harvest hit table <b>2201</b> is further updated to reflect those additional harvest events obtained at step <b>2263</b>. Processing terminates at step <b>2265</b>, depicting the return of the internal indication of whether or not to harvest the current testcase set by API entry point <b>2202</b> at either steps <b>2255</b> or <b>2256</b> to RTX <b>1702</b>.

[0489] With reference to FIG. 22C, there is depicted a flow diagram illustrating in greater detail the operation of harvest manager program <b>2215</b> in accordance with a preferred embodiment of the present invention. Harvest manager program <b>2215</b> begins processing at step <b>2280</b> and continues as illustrated at step <b>2281</b>, with a determination of whether a request for a direct network connection over network <b>1720</b> from a simulation client operating in direct non-redundancy verification mode is present.

[0490] If so, and as illustrated at step <b>2282</b>, harvest manager program <b>2215</b> receives the aggregate instrumentation data packet transmitted over the direct network connection on network <b>1720</b> as a part of step <b>2255</b> of FIG. 22B. The process continues at step <b>2283</b>, with harvest manager program <b>2215</b> comparing the contents of the aggregate instrumentation data packet to master harvest hit table <b>2205</b> to determine if any actually new harvest events have occurred and updating, as necessary, master harvest hit table <b>2205</b> to record these new events (step <b>2283</b>).

[0491] Proceeding to step <b>2284</b>, harvest manager program <b>2215</b> determines if any new harvest events have been recorded at step <b>2283</b>. If new harvest events have been recorded at step <b>2283</b>, harvest manager program <b>2215</b> returns an indication through the direct network connection on network <b>1720</b> instructing the simulation client to copy the current testcase into harvest testcase bucket <b>2300</b> as depicted at step <b>2285</b>. If no new harvest events are recorded at step <b>2283</b>, an indication is delivered from harvest manager program <b>2215</b> through the direct network connection on network <b>1720</b> instructing the simulation client not to collect the current testcase within harvest testcase bucket <b>2300</b> as depicted at step <b>2286</b>.

[0492] The process continues at step <b>2287</b>, which illustrates a determination of whether an aggregate instrumentation data packet from a simulation client operating in indirect non-redundancy verification mode has been delivered from simulation client <b>1701</b>. If an aggregate instrumentation data packet has been delivered, the process continues as illustrated at step <b>2288</b>, with harvest manager program <b>2215</b> receiving the aggregate instrumentation data packet delivered to harvest manager program <b>2215</b> as a part of step <b>2256</b> of FIG. 22B. Continuing at step <b>2289</b>, harvest manager program <b>2215</b> compares the contents of the aggregate instrumentation data packet to master harvest hit table <b>2205</b> to determine if any actually new harvest events have occurred and updating, as necessary, master harvest hit table <b>2205</b> to record these new events.

[0493] Next, as depicted at step <b>2330</b> harvest manager program <b>2215</b> undertakes processing steps required to resolve inconsistencies between the testcases collected within harvest testcase bucket <b>2300</b> and the testcases recorded within master harvest hit table <b>2215</b>. The particular processing steps performed during step <b>2330</b> are explained in further detail with reference to FIGS. <b>23</b>A-<b>23</b>C. In this manner, harvest manager program <b>2215</b> processes aggregate instrumentation data packets received from simulation clients in both direct and indirect harvest mode. The process returns to step <b>2281</b> to repeat for each direct or indirect non-redundancy inquiry delivered by the simulation client. The above described mechanism for harvesting testcases provides for a robust and efficient means to collect testcases, minimizing duplication where possible, that exercise harvest events in batch simulation farm <b>1601</b>.

[0494] The mechanism for harvesting testcases described with reference to FIGS. <b>22</b>A-<b>22</b>C has two main sources of inconsistency between the entries within master harvest hit table <b>2205</b> and the testcases recorded in harvest testcase bucket <b>2300</b>. The first of these inconsistencies, referred to hereafter as a “lost harvest testcase”, occurs when a harvest event is recorded in master harvest hit table <b>2205</b> in association with a particular testcase, but RTX <b>1702</b> fails to successfully store the testcase on harvest testcase server <b>2210</b>. In such a circumstance, master harvest hit table <b>2205</b> includes a harvest event entry for a testcase that is not actually stored within harvest testcase bucket <b>2300</b>. As such, subsequent testcases that trigger the object harvest event will not be collected within harvest testcase bucket <b>2300</b>. Left uncorrected, this condition prevents any future collection of testcases that trigger harvest events whose recordation within master harvest hit table <b>2205</b> has become effectively erroneous.

[0495] The second source of inconsistency between the entries within master harvest hit table <b>2205</b> and the testcases recorded in harvest testcase bucket <b>2300</b>, referred to hereafter as an “extraneous harvest testcase”, may occur as a result of the nature of the previously described indirect redundancy verification mode optionally undertaken by API entry point rpt_hrv( ) <b>2202</b>. As previously explained with reference to FIGS. <b>21</b>A-<b>21</b>C, an indirect non-redundancy status inquiry results in the possibility that testcases which are redundant with respect to a given harvest event may be collected in association with a given simulation model within harvest testcase bucket <b>2300</b>. This is despite the fact that only one testcase is recorded per harvest event in master harvest hit table <b>2205</b>. The collection of potentially thousands of extraneous testcases within harvest testcase bucket <b>2300</b> is inherently undesirable. Furthermore, it is not possible to definitively determine from master harvest hit table <b>2205</b> which harvest events are triggered by these extraneous testcases.

[0496] It would therefore be advantageous to provide a means, hereafter referred to as “harvest annealing”, to resolve these inconsistencies. Referring to FIG. 23A, there are depicted additional elements within instrumentation server <b>1699</b> and harvest testcase server <b>2210</b> that are utilized in resolving inconsistencies between master harvest hit table <b>2205</b> and harvest testcase bucket <b>2300</b>.

[0497] As illustrated in FIG. 23A, the contents of memory <b>44</b> within harvest testcase server <b>2210</b> and instrumentation server <b>1699</b> utilized to implement harvest annealing include a harvest annealing program <b>2305</b> and harvest manager program <b>2215</b>, respectively. At proscribed intervals, harvest testcase server <b>2210</b> initiates harvest annealing program <b>2305</b> for a given simulation model. Harvest annealing program <b>2305</b> first opens a direct network connection on network <b>1720</b> to harvest manager program <b>2215</b> executing on instrumentation server <b>1699</b>. Harvest annealing program <b>2305</b> delivers harvest testcase list <b>2214</b>, which contains a list of the names of all testcases stored on harvest testcase server <b>2210</b> for the given model, to harvest manager program <b>2215</b>.

[0498] Harvest manager program <b>2215</b> compares the testcase name fields within master harvest hit table <b>2205</b> to the entries of testcase list <b>2214</b>. Any entry in master harvest hit table <b>2215</b> whose testcase field does not correspond to any testcase name entry within harvest testcase list <b>2214</b> indicates a lost harvest testcase that is not present in harvest testcase bucket <b>2300</b>. Detection of such lost harvest testcases results in the removal of the corresponding harvest event entries from master harvest hit table <b>2205</b>. Removal of these harvest event entries from master harvest hit table <b>2205</b> enables collection of testcases triggering the object harvest events during future simulation jobs.

[0499] As a further step in the comparison, harvest manager program <b>2215</b> produces a list of each testcase recorded in harvest testcase list <b>2214</b> which cannot be correlated with the testcase field of an entry in master harvest hit table <b>2205</b>. These testcases correspond to the extraneous harvest testcases described above. This list of extraneous testcases <b>2302</b> is returned to harvest annealing program <b>2305</b> over the direct network connection on network <b>1720</b>. Harvest annealing program <b>2305</b> removes the extraneous testcases indicated in the extraneous testcase list from harvest testcase bucket <b>2300</b>.

[0500]FIG. 23B provides a more detailed illustration of the data structure and content of harvest testcase list <b>2214</b> and master harvest hit table <b>2205</b> as they exist prior to the harvest annealing process of the present invention. Within harvest testcase list <b>2214</b>, a name field <b>2360</b> includes data field entries containing the names of testcases, test1, test2, test3, test4, and test5, which are stored on harvest testcase server <b>2010</b> in association with simulation model <b>1700</b>.

[0501] Master harvest hit table <b>2205</b> includes row-wise entries for harvest events that have been recorded by simulation clients in the course of simulation on batch simulation farm <b>1601</b>. Each harvest event entry within master harvest hit table <b>2205</b> includes an extended event identifier field <b>2362</b> that contains the name of the harvest event. Each entry also includes a testcase name field <b>2363</b> that contains the name of the testcase that triggered the corresponding harvest event. An instance identifier field <b>2361</b> is also included within each entry to provide an indication of the specific instance of the harvest event that was triggered. Harvest events may be collected in either a hierarchical or non-hierarchical mode. In a hierarchical mode, each instance of a given harvest event is processed independently, and a separate testcase exercising each instance of the harvest event may be collected accordingly. In such a case, when determining if a reported harvest event is new, harvest manager program <b>2215</b> considers instance identifier field <b>2361</b>.

[0502] In non-hierarchical mode, harvest events are collected in harvest testcase bucket <b>2300</b> without regard to each specific instance of a given harvest event. Once a testcase exercising a particular instance of a harvest event is detected and recorded, no further testcases are collected for that event. To this end, instance identifier field <b>2361</b> is ignored by harvest manager program <b>2215</b> when operating in non-hierarchical harvest mode.

[0503] Regardless of the harvest annealing mode selected by harvest manager program <b>2215</b>, instance identifier field <b>2361</b> is present in master harvest hit table <b>2205</b>. In either mode, instance identifier field <b>2361</b> maintains the potential utility in determining which specific instance of the harvest event has been triggered by a given testcase.

[0504] In comparing the exemplary entries within harvest testcase list <b>2214</b> with the entries in master harvest hit table <b>2205</b>, a “lost testcase” entry <b>2264</b> contains a harvest event entry (i.e. D B5 L E4) corresponding to a testcase (i.e. test7) that is not included among the testcase names contained in harvest testcase list <b>2214</b>. Responsive to the harvest annealing file comparison for the exemplary files depicted FIG. 23B, entry <b>2264</b> is removed from master harvest hit table <b>2205</b>.

[0505] As further depicted in FIG. 23B, harvest testcase list <b>2214</b> includes two entries, test2 and test5, which are not included within any entry within test case name field <b>2363</b> of master harvest hit table <b>2205</b>. As previously explained with reference to FIG. 23A, such extraneous testcase entries will be removed from harvest testcase bucket <b>2300</b> and harvest testcase list <b>2214</b> within harvest testcase server <b>2210</b>.

[0506] Referring to FIG. 23C, there is depicted a flow diagram illustrating in further detail the steps performed by harvest manager program <b>2215</b> during step <b>2330</b> of FIG. 22C to process annealing requests from harvest testcase server <b>2210</b>. The process begins at step <b>2370</b> and proceeds to step <b>2371</b>, which depicts harvest manager program <b>2215</b> receiving harvest testcase list <b>2214</b> from harvest testcase server <b>2210</b>. Next, as illustrated at step <b>2372</b>, harvest manager program <b>2215</b> sequentially examines the entries within harvest testcase list <b>2214</b> and marks an internal flag (not depicted in FIG. 23B) in master harvest hit table <b>2205</b> for each entry whose testcase name field <b>2363</b> corresponds to an entry in harvest testcase list <b>2214</b>.

[0507] At the conclusion of the examination of testcase list <b>2214</b>, any unmarked entries in master harvest hit table <b>2205</b> correspond to the set of lost testcase inconsistencies. In addition, while sequencing through harvest testcase list <b>2214</b>, harvest manager program <b>2215</b> creates an extraneous testcase list containing testcase names that have no corresponding entry in master harvest hit table <b>2205</b>.

[0508] The process continues as illustrated at step <b>2734</b>, which depicts master harvest program <b>2215</b> removing the unmarked entries from master harvest hit table <b>2205</b>. Proceeding as depicted at step <b>2375</b>, harvest manager program <b>2215</b> returns the extraneous testcase list to harvest testcase server <b>2210</b> over the direct network connection on network <b>1720</b>. Harvest testcase server <b>2010</b> will, at a later time, remove these extraneous testcases from harvest testcase bucket <b>2300</b> and harvest testcase list <b>2214</b>. The harvest annealing process then terminates as depicted at step <b>2376</b>. The above-described process provides a means by which to resolve inconsistencies arising in the process of harvesting testcases in a geographically distributed batch simulation farm <b>1601</b>.

[0509] In the means described above for creating and managing instrumentation events in a batch simulation farm, instrumentation events are generated from HDL code or, as described above in conjunction with FIGS. 12A and 12B, from unconventional comments. The HDL code and/or unconventional comments are compiled into instrumentation entities within the simulation model by instrumentation load tool <b>464</b>. In the following descriptions of FIGS. <b>24</b>A-<b>24</b>C, a logic function that detects the occurrence of an instrumentation event (represented by logic <b>402</b> in FIG. 4A as one example) will be referred to as “instrumentation logic”, and instrumentation events created from HDL code or unconventional comments will be referred to as “HDL instrumentation events”.

[0510] As described above, instrumentation server <b>1699</b> controls HDL instrumentation events utilizing a number of API entry points called by RTX <b>1702</b> during execution of testcases. Furthermore, instrumentation server <b>1699</b> retrieves data from HDL instrumentation events for storage and processing utilizing additional API entry points called by RTX <b>1702</b>. These mechanisms provide an efficient means by which an HDL circuit designer can generate HDL instrumentation events that are managed and recorded in a largely automatic fashion by instrumentation server <b>1699</b>. Under some circumstances, however, utilizing HDL code and/or unconventional comments to produce instrumentation logic can prove to be inefficient.

[0511] In particular, it is often the case that complex instrumentation events occur over many cycles and are composed of temporally complex interactions of a large number of signals within the given simulation model. Detecting such instrumentation events typically requires a complex functionality that necessitates a correspondingly complex modeling data structure. In such a circumstance, using HDL code or unconventional comments to create the necessary instrumentation logic can be difficult and inefficient.

[0512] In general, the instrumentation functionality required to detect such complex instrumentation events is usually more effectively created utilizing a high-level programming language such as C or C++. High-level programming languages typically provide more direct support for complex data structures and provide features such as dynamic memory allocation, among others, that allow for the more efficient generation of functionality suited to the detection of complex instrumentation events. Furthermore, simulation engineers are often not primarily conversant in HDLs, but instead rely on high-level programming languages such as C or C++.

[0513] It would therefore be advantageous to provide a means by which to generate and process instrumentation events, hereafter referred to as RTX instrumentation events, under RTX control utilizing a high-level language such as C or C++. Such a means would enable simulation engineers to more efficiently generate complex instrumentation events with the additional flexibility inherent in high-level programming languages.

[0514] As explained in further detail hereinbelow, RTX instrumentation events, unlike HDL instrumentation events, can be used to track the occurrence of events that are not composed of sequences of signals within a given simulation model. As an example, conventional RTXs typically receive as inputs a number of control parameters that guide the subsequent behavior of the RTX during execution of a given simulation model. It is often useful to be able to determine the number of testcases that have been executed with a particular control parameter set to a particular one of its possible legal values. In this way, it is possible to determine how often the simulation model has been exercised in each of the possible modes controlled by the given control parameter. Likewise it is possible to extend this notion in order to collect statistics on combinations of control parameters and their respective values for different simulation runs.

[0515] Such RTX control parameters are outside the scope of the simulation model and therefore are not directly accessible by HDL instrumentation events that must ultimately take as inputs signals within the simulation model itself. In accordance with the principles set forth herein, an RTX, such as RTX <b>1702</b>, may generate a number of RTX count instrumentation events to collect statistics related to the RTX input parameter values for each executed testcase. Specifically, at the beginning of each testcase, the RTX triggers count events corresponding to the values assigned to the input RTX control parameter values. At the conclusion of the testcase, the resultant counts for the triggered count events are communicated to the instrumentation server for storage and analysis.

[0516] The present invention specifies additional API entry points that allow an RTX, utilizing a high-level programming language such as C or C++, to generate and process RTX instrumentation events. In what follows, the high-level language programming code formulated to detect the occurrence of an RTX instrumentation event will be referred to as “instrumentation code” to distinguish it from instrumentation logic for HDL instrumentation events that is specified by HDL code or unconventional comments. Instrumentation code for RTX instrumentation events that are related to signals within a given simulation model typically consists of a number of calls to API entry point GETFAC( ) to obtain signal values within the model, and also includes program instructions that operate on the obtained signal values in order to detect the object instrumentation event.

[0517] In accordance with the system of the present invention, RTX instrumentation events and HDL instrumentation events are respectively maintained as distinct groups with separate namespaces. This namespace separation prevents name collisions between HDL and RTX instrumentation events, and provides a barrier between the activities and goals of HDL chip designers creating HDL instrumentation events and simulation engineers creating RTX instrumentation events.

[0518] To support RTX instrumentation events, API entry points that interact with individual instrumentation events, such as API entry point <b>1802</b>, set_fail_mask( ), are augmented with an additional parameter that specifies whether the routine will process an RTX instrumentation event or an HDL instrumentation event. API entry points, such as rpt_fails( ), rpt_counts( ), rpt_harv( ), disable_events( ), etc., which facilitate control of an entire class of HDL instrumentation events, or which record data from an entire class of HDL instrumentation events simultaneously, are similarly enhanced to concurrently support RTX instrumentation events. Specifically, these API entry points are augmented to generate and deliver aggregate instrumentation data packets for the RTX instrumentation events, and to receive from instrumentation server <b>1699</b>, separate control information utilized to control the RTX instrumentation events. For example, API entry point <b>1900</b>, rpt_fails( ), is enhanced to enable delivery of two aggregate instrumentation data packets to instrumentation server <b>1699</b>: one containing fail event information for any HDL instrumentation events present in the simulation model; and one containing fail information for any generated RTX instrumentation events.

[0519]FIG. 24A depicts data structure representations of API entry points designed to support the generation and operation of RTX instrumentation events in accordance with a preferred embodiment of the present invention. Specifically, an API entry point <b>2400</b>, create_event( ), when called by RTX <b>1702</b>, initiates generation and naming of RTX instrumentation events. FIG. 24A further illustrates an API entry point <b>2401</b>, trigger_event( ), which is called by RTX <b>1702</b> to indicate the occurrence of the RTX instrumentation event generated in response to API entry point <b>2400</b>. API entry point <b>2400</b> returns a pointer <b>2402</b> to the generated RTX instrumentation event. Pointer <b>2402</b> is subsequently used as an input parameter to API entry point <b>2401</b>. When API entry point <b>2401</b> is called with a particular pointer parameter <b>2403</b>, the corresponding RTX instrumentation event generated in reference to that pointer is triggered as described in further detail with reference to FIG. 24D.

[0520] Within API entry point <b>2400</b>, a type parameter <b>2409</b> specifies the RTX instrumentation event type (e.g. fail, count, harvest, etc.). Additional naming specification parameters <b>2410</b>, <b>2411</b>, <b>2412</b>, and <b>2413</b>, specify the name of the RTX instrumentation event in accordance with HDL instrumentation event naming convention. Each RTX instrumentation event is therefore typically identified by an extended event identifier consisting of the four fields explained with reference to FIG. 10B.

[0521] As further explained with reference to FIG. 10, extended event identifiers for HDL instrumentation events are derived at model build time directly in accordance with the structure of the simulation model and the names assigned by unconventional comments to the HDL instrumentation events. For RTX instrumentation events, in contrast, RTX <b>1702</b> directly sets the extended event identifier fields at runtime utilizing API entry point <b>2400</b>, and furthermore ensures that each RTX instrumentation event within a given class (fail, count, harvest, etc.) is generated with a unique name. Fields <b>1030</b>, <b>1032</b>, <b>1034</b>, and <b>1036</b> (described with reference to FIG. 10B) of the extended event identifier for an HDL instrumentation event are specified for an RTX instrumentation event by naming specification parameters <b>2410</b>, <b>2411</b>, <b>2412</b>, and <b>2413</b>, respectively.

[0522] The extended event identifiers for RTX instrumentation events serve functions analogous to those served by extended event identifiers for HDL instrumentation events. For example, extended event identifiers for RTX instrumentation events are used to form eventlist files for the RTX instrumentation events. These eventlist files are created during each simulation model test run and are commissioned on instrumentation server <b>1699</b> in the same manner as the eventlist files associated with HDL instrumentation events. Furthermore, RTX instrumentation events which share the same values for type parameter <b>2409</b>, instrument code parameter <b>2411</b>, design entity parameter <b>2412</b>, and instrumentation event parameter <b>2413</b>, while having differing values for instance parameter <b>2410</b>, are processed by instrumentation server <b>1699</b> as differing instances of the same instrumentation event (analogous to the treatment by instrumentation server <b>1699</b> of instrumentation events that are replicated instances of a given HDL instrumentation event).

[0523] When commissioning eventlist files, instrumentation server <b>1699</b> generally does not distinguish between eventlist files for HDL instrumentation events generated during model build, and eventlist files for RTX instrumentation events generated by RTX <b>1702</b>. Instrumentation server <b>1699</b> can therefore support and process RTX instrumentation events utilizing aforementioned instrumentation event processing mechanisms, (i.e. as if the RTX instrumentation events were HDL instrumentation events associated with another simulation model).

[0524] To enable instrumentation server <b>1699</b> to reuse the same processing means employed for HDL instrumentation events for processing RTX instrumentation events, it is necessary to provide a means to assign the equivalent of a simulation model name. As utilized herein, this equivalent to the simulation model name is referred to as the “rtx name”, which is specified for a group of RTX instrumentation events. As further illustrated in FIG. 24A, an API entry point <b>2405</b>, set_rtxname( ), receives an input string parameter <b>2406</b>, which specifies the rtx name to be associated with the RTX instrumentation events generated in accordance with API entry point <b>2400</b>. The rtx name associated with a group of RTX instrumentation events serves an analogous role as the simulation model name for HDL instrumentation events. For example, the model name field <b>1751</b> (FIG. 17B) for an aggregate instrumentation data packet corresponding to a set of RTX instrumentation events, contains the rtx name specified by API entry point <b>2405</b> for the corresponding RTX instrumentation events.

[0525] The set of HDL instrumentation events associated with a given simulation model is fixed at model build time, allowing instrumentation server <b>1699</b> to validate aggregate instrumentation data packets according to the means described above in conjunction with FIGS. <b>17</b>A-C. Likewise, the set of RTX instrumentation events associated with a given RTX name is also fixed. To this end, RTX <b>1702</b> must ensure that for a given rtx name, the same set of RTX instrumentation events are generated by each simulation run performed by RTX <b>1702</b>.

[0526] If RTX instrumentation events must be added or removed from RTX <b>1702</b>, a new version of RTX <b>1702</b> is produced and tested in a series of foreground simulation runs. Once debugged, a new RTX name is assigned to the new version of RTX <b>1702</b>, which is run once to create eventlist files corresponding to the new rtx name and the new set of RTX instrumentation events. These new eventlist files are commissioned on instrumentation server <b>1699</b> to inform instrumentation server <b>1699</b> of the new RTX version. Instrumentation server <b>1699</b> may then process data associated with the RTX instrumentation events present in the new version of RTX. In essence, each generation of a different set of RTX instrumentation events that constitute a different version of the RTX, is analogous to new versions of a simulation model being produced to alter the set of HDL instrumentation events within that model.

[0527] An additional API entry point <b>2407</b>, write_eventlists( ), is called by RTX <b>1702</b> to produce the eventlist files for the RTX instrumentation event generated by API entry point <b>2400</b>. Typically, API entry point <b>2407</b> is not called on every execution of RTX <b>1702</b>, but rather is called only in response to the generation of a new version of RTX <b>1702</b>. The generated eventlist files are then commissioned on instrumentation server <b>1699</b>.

[0528] Referring now to FIG. 24B, there is depicted the contents of memory <b>44</b> utilized during processing of a simulation job that employs RTX instrumentation events performed with respect to simulation model <b>1700</b> within simulation client <b>1701</b>. For clarity of explanation of the depicted embodiment, it is assumed that the simulation job includes only a single testcase. The extensions necessary to support multiple testcases within the simulation job are readily apparent to one skilled in the art.

[0529] In the depicted embodiment, RTX <b>1702</b> begins the process of generating RTX instrumentation events by calling API entry point <b>2405</b> to assign an rtx name to the set of RTX instrumentation events that will be generated. API entry point <b>2405</b> produces an rtx name data structure <b>2441</b>, which is utilized by API entry point <b>2407</b> to name the created eventlists. Rtx name data structure <b>2441</b> is also used by those API entry points, such as rtp_harv( ) for example, that create aggregate instrumentation data packets, to specify the value of model name field <b>1751</b> within the aggregate instrumentation data packets.

[0530] RTX <b>1702</b> subsequently makes a series of calls to API entry point <b>2400</b>, create_event( ), to generate the desired RTX instrumentation events. For each RTX instrumentation event, API entry point <b>2400</b> creates an event data structure <b>2440</b>. Event data structure <b>2440</b> consists of two primary elements: a disable flag <b>2445</b> that serves to disable the RTX instrumentation event in a manner similar to latch <b>507</b> of FIG. 5A, and data element <b>2446</b> that stores the contents of the RTX instrumentation event (i.e. a count field for a count event, a flag and a cycle count field for a harvest event, and a flag for a fail event). As a further step in generating RTX instrumentation events, API entry point <b>2400</b> creates an RTX instrumentation eventlist data structure <b>2442</b>, which lists the extended event identifiers and event types for each of the object RTX instrumentation events. RTX instrumentation eventlist data structure <b>2442</b> is utilized by API entry point <b>2407</b>, write_eventlists( ), to create the RTX instrumentation eventlist files. If necessary, RTX <b>1702</b> then calls API entry point <b>2407</b>, write_eventlists( ), to create the eventlist files for the created RTX instrumentation events. As previously explained, API entry point <b>2407</b> is typically only called for a single, initial execution of RTX <b>1702</b> to create the RTX instrumentation event eventlist files. Once the RTX instrumentation event eventlist files are created and subsequently commissioned with instrumentation server <b>1699</b>, API entry point <b>2407</b> is no longer called for the newly defined version of RTX <b>1702</b>.

[0531] RTX instrumentation event processing continues with RTX <b>1702</b> calling those event initialization API entry points, such as init_harv( ), disable_events( ), etc., utilized to initialize processing for HDL and RTX instrumentation events. As explained with reference to the foregoing figures, these API entry point routines are augmented to operate on event data structures, such as event data structure <b>2440</b><i>a</i>-<b>2440</b><i>n</i>, when processing RTX instrumentation events. These routines further utilize rtx model name data structure <b>2441</b> in order to determine, by rtx name, the proper set of control files stored on instrumentation server <b>1699</b> associated with the given RTX instrumentation events.

[0532] After calling the appropriate event initialization API entry points, RTX <b>1702</b> typically enters a main processing loop <b>2450</b>, which serves to progress simulation model <b>1700</b> through simulation cycles during execution of the testcase. Main processing loop <b>2450</b> begins with initialization processing steps required for the execution of a simulation cycle. After completing this initialization processing, main processing loop <b>2450</b> proceeds with execution of a number of instrumentation code blocks <b>2451</b><i>a</i>-<b>2451</b><i>n</i>, wherein each of instrumentation code blocks <b>2451</b><i>a</i>-<b>2451</b><i>n </i>corresponds to a single RTX instrumentation event. Each of instrumentation code blocks <b>2451</b><i>a</i>-<b>2451</b><i>n </i>typically consists of a number of calls to an API entry point GETFAC, which retrieves the value of signals within simulation model <b>1700</b>. Program instructions within an instrumentation code block <b>2451</b> then process these signal values to determine if the corresponding RTX instrumentation event has occurred. If so, API entry point <b>2401</b>, trigger_event( ), is called to record the occurrence of the RTX instrumentation event. Within main loop <b>2450</b>, RTX <b>1702</b> then calls an API entry point cycle( ) (not shown in FIG. 24B), which advances simulation model <b>1700</b> a single simulation cycle. Main loop <b>2450</b> continues in this fashion until the testcase has completed.

[0533] Upon completed execution of the testcase, RTX <b>1702</b> calls those event post-processing API entry points, such as rpt_harv( ), rpt_count( ), etc., which then report information collected for HDL and RTX instrumentation events. As previously explained, these post-processing routines are augmented to operate on event data structures, such as event data structures <b>2440</b><i>a</i>-<b>2440</b><i>n</i>, as part of processing RTX instrumentation events. Furthermore, these post-processing routines forward rtx model name data structure <b>2441</b> to set model name field <b>1751</b> in aggregate instrumentation data packets delivered to instrumentation server <b>1699</b> for the RTX instrumentation events.

[0534] With reference to FIG. 24C, there is shown a flow diagram depicting steps performed by RTX <b>1702</b> during the generation and processing of RTX instrumentation events in accordance with a preferred embodiment of the present invention. The process beings at step <b>2460</b> and proceeds to step <b>2461</b>, which depicts RTX <b>1702</b> setting the rtx name by calling API entry point <b>2405</b>. The process continues as illustrated at step <b>2462</b>, with the generation of the RTX instrumentation events by a series of calls to API entry point <b>2400</b>, create_event( ).

[0535] Next, a determination is made of whether or not to write the RTX instrumentation event eventlist files, as depicted at step <b>2463</b>. If the eventlist files are to be written, processing continues as illustrated at step <b>2464</b>, with the eventlist files being written in response to a call to API entry point <b>2407</b>, write_eventlists( ). Otherwise processing continues at step <b>2464</b>, which depicts the execution of instrumentation code blocks <b>2451</b><i>a</i>-<b>2451</b><i>n</i>. Proceeding to step <b>2465</b>, a determination is made of whether the testcase has completed. If the testcase has not completed, the process returns to step <b>2464</b> for continued execution of instrumentation code blocks <b>2451</b><i>a</i>-<b>2451</b><i>n </i>for the subsequent simulation cycle. Otherwise processing terminates as illustrated at step <b>2466</b>.

[0536] In accordance with the RTX instrumentation event processing disclosed herein, API entry point <b>2401</b>, trigger_event( ), must undertake certain processing steps in order to allow for the selective disabling of RTX instrumentation events. FIG. 24D illustrates a flow diagram of steps depicting in greater detail the operation of API entry point <b>2401</b>.

[0537] As depicted in FIG. 24D, API entry point <b>2401</b> begins processing at step <b>2470</b> upon being called by RTX <b>1702</b>. Next, as illustrated at step <b>2471</b>, a determination is made of whether or not disable flag <b>2445</b> for the given RTX instrumentation event is set. If disable flag <b>2445</b> is set, the process terminates as depicted at step <b>2473</b>. Otherwise, the processing continues as illustrated at step <b>2472</b>, with API entry point <b>2401</b> updating data element <b>2446</b>. The exact nature of the update to data element <b>2446</b> varies with the RTX instrumentation event type. For example, for an RTX counter instrumentation event, the counter within data element <b>2446</b> is incremented. Following the update to data element <b>2446</b>, the process terminates at step <b>2473</b>.

[0538] It should be noted that disable flag <b>2445</b> serves to prevent API entry point <b>2401</b> from operating the corresponding RTX instrumentation event. In accordance with the present invention, selective disablement of RTX instrumentation events is enabled by augmenting API entry point <b>1800</b> to call an enhanced version of API entry point <b>1802</b>, set_fail_mask( ). This enhanced API entry point <b>1802</b> is constructed to set disable flag <b>2445</b> when processing RTX instrumentation events. In this manner, RTX <b>1702</b> can initiate selective disablement of RTX instrumentation events.

[0539] The above-described mechanisms enable the creation and operation of instrumentation events under RTX control in a high-level programming language such as C or C++. In this manner, simulation engineers in particular are able to create instrumentation events utilizing a more robust programming language with greater efficiency for complex instrumentation events. Furthermore, RTX instrumentation events, as described herein, provide the capability of detecting occurrences of events which reside outside the scope of a simulation model.

[0540] The means described above allows for the creation of RTX instrumentation events by simulation engineers utilizing high level programming languages such as C or C++. It would be further advantageous to provide a means for detecting RTX instrumentation events associated with an HDL design entity that is replicated as multiple instantiations within a simulation model. As described above, the HDL-based instrumentation logic utilized to detect an HDL instrumentation event is automatically replicated for each instance of an HDL design entity. As explained with reference to FIGS. <b>4</b>A-<b>4</b>E, this is accomplished at model build time by creating a separate instance of the instrumentation code for each instance of the design entity. In this manner, the instrumentation logic for an HDL instrumentation event is generated without concern or regard for the number or location of the instances of the given design entity.

[0541] However, in the means described above, no means for replication of instrumentation code for RTX instrumentation events based on the number and location of the replicated instances of the monitored design entity is provided. The means described above enables creation of specified RTX instrumentation events, but is unaware of the internal structure of the simulation model on which it is operating.

[0542] Without such simulation model structure awareness on the part of the RTX, an RTX is required to be cognizant of the internal structure, including the number and location of replicated instances, of design entities for which RTX instrumentation events are desired for all the different simulation models containing these entities. Such a requirement places a considerable bookeeping burden on the simulation engineer. The present invention alleviates this problem by associating one or more “instrumentation code modules” with HDL design entities in a simulation model. As explained in further detail below, the instrumentation code modules are dynamically loaded and processed by the RTX to provide a centralized mechanism for automatically instrumenting each instance of the given HDL design entity within any given simulation model in which the design entity is incorporated.

[0543] Discovery of the instances of relevant design entities for which automatically replicated RTX instrumentation events are desired is enabled by determining the internal structure of each simulation model. To this end, model build tool <b>446</b> (depicted in FIG. 4D) includes further processing and program instruction means for inserting a “design entitylist data structure” into each simulation model <b>480</b> at model build time. The design entitylist data structure contains information identifying all design entities instantiated within the simulation model. The identification of all constituent design entities, including those containing no instantiated HDL instrumentation events, on a per-simulation model basis enable a subsequent identification of design entity instances for which it is desired to associate an automatically replicated RTX instrumentation event. Since the method of the present invention does not permit the association of RTX instrumentation events with HDL instrumentation entities, instrumentation entities within a simulation model are excluded from the design entitylist data structure.

[0544]FIG. 25A depicts a high-level block diagram representation of simulation model <b>329</b> of FIG. 4B augmented with a design entitylist data structure <b>2500</b>. Design entitylist data structure <b>2500</b> includes entries <b>2503</b><i>a</i>-<b>2503</b><i>i </i>each representing one instance of a design entity within simulation model <b>329</b>. Each of entries <b>2503</b><i>a</i>-<b>2503</b><i>i </i>further includes an instantiation identifier field <b>2501</b> and a design entity name field <b>2502</b>. The data structure of entries <b>2503</b><i>a</i>-<b>2503</b><i>i </i>thus identifies each instance of any given design entity within the given simulation model.

[0545] Automatic replication of RTX instrumentation events for a given repeated design entity within a simulation model is enabled by the generation and processing of dynamically loaded “instrumentation code modules”. These modules consist of high level program language instruction code with distinct entry points, fixed by convention, that generate and process RTX instrumentation events associated with the instances of a given design entity within a simulation model. API routines described above in conjunction with FIGS. <b>24</b>A-<b>24</b>D are utilized by the instrumentation code modules to generate and process RTX instrumentation events.

[0546] In accordance with a preferred embodiment of the present invention, instrumentation code modules are dynamically loaded and bound to an RTX at runtime using a technique well known to those skilled in the art referred to as “dynamic loading”. Essentially all modern operating systems, including but not limited to Microsoft Windows®, UNIX®, and Linux®, provide dynamic loading. In dynamic loading, a module containing program code and certain defined entry points is loaded into memory <b>44</b> of a general purpose computer and linked to a currently running program, such as an RTX. The program that is dynamically loading a module can then call entry points within the dynamically loaded module and thereby execute programming instructions contained within the dynamically loaded module. Likewise, subject to certain constraints in the way the dynamically loaded module is bound, the dynamically loaded module can call certain entry points, such as GETFAC( ), CREATE_EVENT( ), TRIGGER_EVENT( ), etc. within the currently running program and its environment.

[0547] Utilizing the teachings of the present invention, one or more instrumentation code modules are created for each HDL design entity that is to be instrumented using RTX instrumentation events. Each of these modules contains fixed entry points described below and serves to create and monitor a set of RTX instrumentation events associated with the instances of the given HDL design entity. However, conventional dynamic loading permits only one copy of a given instrumentation code module to be bound to a running program (i.e. RTX). Therefore, it is not possible to bind a separate instance of the instrumentation code module to each instance of a given HDL design entity to achieve an analogous result as with automatically replicated HDL instrumentation modules. Consequently, an instrumentation code module utilizes a single set of program instructions and dynamically created data structures to monitor the different instances of the given design entity within the simulation model.

[0548] With reference now to FIG. 25B, there is shown a representation of instrumentation code module <b>2510</b> having program entrypoints <b>2511</b>, <b>2512</b>, and <b>2514</b>. Entrypoint <b>2511</b>, create_instance( ), is called to prompt program code within instrumentation code module <b>2510</b> to create the data structures necessary for a given instance of a design entity. A separate call to entrypoint <b>2511</b> is made for each instance of the given design entity within the simulation model. An instance name input parameter <b>2513</b> is a string parameter consisting of the hierarchical instance identifier for the given instance of the design entity.

[0549] After all of the instances of the given design entity have been registered with instrumentation code module <b>2510</b> by means of calls to entry point <b>2511</b>, entrypoint <b>2512</b>, evaluate( ), may be called to execute program instruction steps within instrumentation code module <b>2510</b> which monitor the simulation model to detect occurrences of the desired RTX instrumentation events. These program instruction steps utilize the API entry points described above in conjunction with FIG. 24A to trigger RTX instrumentation events.

[0550] Instrumentation code modules having entrypoints <b>2511</b>, <b>2512</b>, and <b>2514</b> are designed to facilitate monitoring of the RTX instrumentation events within a given design entity. Additional API entrypoint routines, load_modules( ) and execute_modules( ), provided by the present invention and described later, are utilized to manage dynamically loading instrumentation code modules and calling entrypoints <b>2511</b>, <b>2512</b>, and <b>2514</b>. Entrypoint load_modules( ) utilizes API entrypoint <b>2514</b>, entity_name( ), to determine the name of the design entity that instrumentation code module <b>2510</b> is to be associated with. Entrypoint <b>2514</b> returns a pointer (not shown in FIG. 25B) to a string containing the name of the given design entity.

[0551] Referring to FIG. 25C, there is depicted data structure representations of API entry points designed to manage dynamically loading and calling instrumentation code modules. An API entry point <b>2520</b>, load_modules( ), is utilized to load and initialize those dynamic instrumentation code modules required by the current simulation model. An input parameter <b>2522</b> is utilized to indicate the location on a disk storage system where the instrumentation code modules are stored. An entrypoint <b>2521</b>, execute_modules( ), is utilized to call entrypoint <b>2512</b> of the instrumentation code modules during each cycle of simulation to allow the instrumentation code modules to monitor their respective design entities for the occurrence of RTX instrumentation events.

[0552] With reference to FIG. 25D, there is depicted the contents of memory <b>44</b> utilized during processing of a simulation job that employs instrumentation code modules processed with respect to simulation model <b>1700</b> within simulation client <b>1701</b>. For clarity of explanation of the depicted embodiment, it is assumed that the simulation job includes only a single testcase. The extensions necessary to support multiple testcases within the simulation job are readily apparent to one skilled in the art. In the depicted embodiment, RTX <b>1702</b> begins the process of processing instrumentation code modules by first calling API entry point <b>2520</b> to load and initialize instrumentation code modules <b>2510</b><i>a</i>-<b>2510</b><i>n</i>. API entry point <b>2520</b>, under control of input parameter <b>2522</b>, searches disk storage unit <b>2007</b> to locate instrumentation code modules <b>2510</b><i>a</i>-<b>2510</b><i>n. </i>

[0553] API entrypoint <b>2520</b> processes each instrumentation code module <b>2510</b> according to a series of steps. First, entrypoint <b>2520</b> dynamically loads an instrumentation code module <b>2510</b> into memory <b>44</b> of simulation client <b>1701</b>. API entry point <b>2520</b> then calls entrypoint <b>2514</b>, entity_name( ), of each instrumentation code module <b>2510</b> to determine, by design entity name, which HDL design entity each instrumentation code module <b>2510</b> is to be associated with. API entry point <b>2520</b> then searches design entity data structure <b>2500</b> to determine if the HDL design entity identified in the preceding step is instantiated within simulation model <b>1700</b>. If the desired design entity is not instantiated within simulation model <b>1700</b>, API entry point <b>2520</b> removes the object instrumentation code module from memory <b>44</b> of simulation client <b>1701</b> and continues processing with the next instrumentation code module on disk storage unit <b>2007</b>.

[0554] If, however, one or more instances of the desired design entity are present within simulation model <b>1700</b>, API entrypoint routine <b>2520</b> responds by calling entrypoint <b>2511</b> in instrumentation module <b>2510</b>. Entrypoint <b>2511</b> is called by API entrypoint <b>2520</b> once for each instantiation of the desired design entity, and is passed the hierarchical instance identifier for the instance of the design entity. In this manner, instrumentation code module <b>2510</b> is made aware of the location of every instance of the desired design entity. Instrumentation code module <b>2510</b> responds to the instance calls to <b>2511</b> by generating instance data structures <b>2530</b><i>a</i>-<b>2530</b><i>n</i>. The instance data structures <b>2530</b><i>a</i>-<b>2530</b><i>n </i>contain the information, among other things the hierarchical instance identifier, necessary to monitor RTX instrumentation events in each instantiation of the object design entity. Furthermore, upon successful binding and initialization of instrumentation code module <b>2510</b>, API entry point <b>2520</b> adds an entry to an instrumentation code module table <b>2550</b>. Instrumentation code module table <b>2550</b> consists of a list of pointers to the successfully bound instrumentation code modules <b>2510</b>. This process is repeated for all instrumentation code modules found on disk storage unit <b>2007</b>.

[0555] After processing each of instrumentation code modules <b>2510</b><i>a</i>-<b>2510</b><i>n</i>, RTX <b>1702</b> enters a main processing loop <b>2450</b>, which processes simulation model <b>1700</b> through simulation clock cycles during execution of the testcase. At the conclusion of each sequence through main processing loop <b>2450</b>, RTX <b>1702</b> calls API entry point <b>2521</b> to execute instrumentation code modules <b>2510</b><i>a</i>-<b>2510</b><i>n</i>. Entrypoint <b>2521</b> utilizes instrumentation code module table <b>2550</b> to call entry point <b>2512</b>, evaluate( ), within each instrumentation code module <b>2510</b>. The program instructions within instrumentation code modules <b>2510</b><i>a</i>-<b>2510</b><i>n </i>utilize corresponding instance data structures <b>2530</b><i>a</i>-<b>2530</b><i>n </i>to determine the locations of the design entity instances and any state information associated with the desired RTX instrumentation events. Further, these program instructions utilize the means described above in conjunction with FIGS. <b>24</b>A-<b>24</b>D to monitor and record the occurrence of RTX instrumentation events.

[0556]FIG. 25E is a flow diagram depicting steps performed by API entry point <b>2520</b> during loading and initialization of instrumentation code modules <b>2510</b><i>a</i>-<b>2510</b><i>n</i>. The process begins at step <b>2888</b> and proceeds to step <b>2551</b>, which depicts API entrypoint <b>2520</b> determining whether or not any instrumentation code modules on disk storage unit <b>2007</b> remain unprocessed for a simulation job. If all instrumentation code modules have been processed or none are present, the process terminates as illustrated at step <b>2552</b>. API entrypoint <b>2520</b> can therefore be called even if no instrumentation code modules are present on disk storage unit <b>2007</b>. If, however, an instrumentation code module <b>2510</b> remains to be processed, the process continues at step <b>2553</b> which depicts API entrypoint <b>2520</b> loading and the given instrumentation module into memory <b>44</b> of simulation client <b>1701</b>. Continuing with step <b>2554</b>, API entrypoint <b>2520</b> calls entrypoint <b>2514</b> to determine the name of the design entity the loaded instrumentation code modules is to be associated with.

[0557] Next, as illustrated at step <b>2555</b>, API entrypoint <b>2520</b> searches instrumentation code module table <b>2550</b> to determine if any instances of the design entity identified at step <b>2554</b> exist in the current simulation model. If no such instances exist, the process continues at step <b>2556</b>, which depicts API entrypoint <b>2520</b> removing the instrumentation module from memory <b>44</b>. Otherwise, the process moves to step <b>2557</b>, which depicts API entrypoint <b>2520</b> calling entrypoint <b>2511</b> in instrumentation code module <b>2510</b> for each instance of the desired design entity listed in instrumentation code table <b>2550</b>. In this manner, instrumentation code module <b>2510</b> is made aware of the instances of the design entity present in the simulation model and can create instance data structures <b>2530</b><i>a</i>-<b>2530</b><i>n</i>. The process then moves back to step <b>2551</b> to repeat the process for each of the instrumentation code modules <b>2510</b><i>a</i>-<b>2510</b><i>n </i>present on disk storage unit <b>2007</b>.

[0558] With reference to FIG. 25F, there is shown a flow diagram depicting steps performed by API entry point <b>2521</b> in executing instrumentation code modules <b>2510</b><i>a</i>-<b>2510</b><i>n </i>during each sequence through main processing loop <b>2450</b>. The process begins at step <b>2570</b> and proceeds to step <b>2571</b>, which depicts API entrypoint <b>2520</b> determining whether or not any instrumentation modules have been successfully loaded by examining instrumentation code module table <b>2550</b>. If all instrumentation code modules have been processed or none are present, the process terminates as illustrated at step <b>2572</b>. API entrypoint <b>2520</b> is therefore called even if no instrumentation code modules were successfully bound by API entrypoint <b>2520</b>. If, however, there is at least one instrumentation code module remaining to be processed, the process continues at step <b>2573</b> which depicts entrypoint <b>2521</b> utilizing the corresponding pointer in instrumentation code module table <b>2550</b> to call entrypoint <b>2512</b>, evaluate( ), in instrumentation code module <b>2510</b>. As illustrated at step <b>2571</b>, the process is repeated for each of the instrumentation code modules <b>2510</b><i>a</i>-<b>2510</b><i>n </i>present in memory <b>44</b> of simulation client <b>1701</b>.

[0559] The embodiments described with reference to FIGS. <b>25</b>A-<b>25</b>F provide a mechanism for the efficient creation and management of instrumentation code modules that monitor RTX instrumentation for all instances of a given design entity within a simulation model. An RTX programmer need only insert calls to API entrypoints <b>2520</b> and <b>2521</b> to enable this mechanism, resulting in a significant reduction in effort for the overall RTX coder. In addition, the simulation engineer creating the instrumentation code module need no longer be aware of the various number and locations of the design entity for the various simulation models. The present invention automatically determines the model configuration and passes this information to the instrumentation code module, resulting in increased efficiency and portability of the instrumentation code modules.

[0560] 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 <b>28</b> of one or more computer systems configured generally as described in FIG. 1 and FIG. 2. Until required by computer system <b>10</b>, the set of instructions may be stored in another computer readable storage device, such as disk drive <b>33</b> 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.