... from concept to design to success, on time, every time!
Insanity is doing things the same old way and expecting different results!
... from concept to design to success, on time, every time!
Insanity is doing things the same old way and expecting different results!
Foresight is a tightly integrate suite of tools for constructing and analyzing executable system models. Foresight operates on standard workstation platforms, taking full advantage of their graphics, networking and window facilities. The user interface is consistent across all the tools, employing mouse-driven pop-up menus, multiple windows and a bit-mapped graphics display.
As illustrated in Figure 9, Foresight provides a variety of graphical and textual
model editors, which allow construction of executable system models. Throughout
system development, system models are stored and maintained in Foresight's
underlying object-oriented database. While constructing models, developers can
use elements from Foresight's reusable libraries as well as any reusable catalogs
that have been created. Foresight's model analyzer checks the static completeness
and consistency of your model. The analyzer will notify the developer with messages
that clearly identify any anomalies in their model. And then, the developer can use
Foresight's simulation engine to execute the model - which will allow the team to
extensively analyze the system's dynamic behavior. The simulator is highly
interactive, allowing users to run the gamut of dynamic analysis: from executing
long simulation runs to single stepping through the model. Just some of the
simulator's capabilities include setting of breakpoints, monitoring the value of
flows, generating test scenarios, and capturing simulation results to files. At
any time, users can generate hardcopy output of any models with Foresight's printing
feature, which supports Postscript format printers and plotters. Full-size hard copy
of drawings may be produced from engineering size "A" (8.5" by 11") up to engineering
size "E" (34" by 44"). Drawings can also be scaled to any size for printing.
In addition to Foresight's modeling and simulation capabilities, it has built-in
interfaces to support a variety of other system lifecycle activities. Foresight's
extensible interfaces are illustrated in Figure 10.
Foresight produces encapsulated PostScript which can be easily incorporated into popular desktop publishing packages such as FrameMaker, Word and Interleaf. Foresight allows extraction of the graphical and textual model components into documents.Also, using the Dump/Load utilities users can extract models out of the object-oriented database into an ASCII format (CDIF) - which users can use to transfer the models to and from computer-aided software engineering (CASE) tools.
Foresight also has a configuration management interface so that users can effectively manage the development of models. Multiple modelers may access different portions of a system model concurrently; model subsystems may be checked in/out with various access permissions (e.g. read/write, read-only). Foresight's configuration management interface facilitates larger project development efforts.
Users can link any software into the executable system models. These packages can be written in a variety of programming languages such as C, C++, JAVA, Ada and assembly language. This allows modelers to take advantage of their existing software. Similarly, developers can link prototypes of graphical user interfaces into the Foresight model executions. Any number of commercially off the shelf GUI builders can be used to mock up the user interface, and link that directly into the dynamic model of the system's functionality and behavior as modeled in Foresight.
Furthermore, through external function call interfaces and FS/Bridgeway users can easily link other simulations into the Foresight simulation environment. This allows modelers to replace portions of their system model with domain specific simulation tools (e.g. VHDL simulators, real-time simulations, any custom simulations, etc.). For example, Foresight's Cmodel interface provides a direct link with Intergraph Electronics' Advansim simulator, for co-executing digital hardware designs.
Figure 11 - Foresight DFD with Anotations
Foresight's model editors capture the functionality, behavior, performance, and information flow of the system under development. They support the creation of all modeling constructs: graphical editors are available for data flow diagrams, state machines, and reusable components, whereas text editors are available for mini-specs and the data dictionary.
On Foresight's graphical model editors, a palette menu is displayed on the left side of the editing window. Each palette is customized to each type of drawing. Thus, when a particular type of diagram is being edited, only relevant types of objects are in the palette menu. Most editing commands are made by choosing items from the palette menu which is done by pointing the cursor to the appropriate icon and clicking the mouse. For example, the data flow diagram editor's palette has icons for data flows, process blocks, and various prompts, whereas the state transition diagram editor palette has icons for states, transitions and I/O blocks.
In addition, the Foresight model editors can create informal general purpose graphics and text diagrams (notes, pictures, or architecture block diagrams) that can be included in the system model, but not analyzed or simulated. As illustrated in Figure 11, the editors can be used to graphically and textually annotate formal model diagrams. In addition, general graphics and text editors are available to create separate drawings or notes. "Hot links" may be established between model diagrams and drawings or notes.
Foresight's model editors maintain links between diagrams so that the user can jump from one related diagram to another with a double-click of a mouse. This feature can be used to walk through the hierarchy of your model by selecting a process and opening it, to maintain links to general drawings or text explaining the model, or to maintain traceability links.
Figure 12 - Foresight System Analyzer
Having edited the model diagrams, the Model Analyzer checks the completeness and consistency of the model. The Model Analyzer traverses all diagrams to identify and report all anomalies; three severity levels are reported: notes, warnings and errors. On the basis of the analysis results, the user can re-edit any diagrams to resolve any anomalies. Figure 12 illustrates an example analyzer output report, along with the messages that direct the user to the precise location of the errors.
A partial analysis may be requested at any level of the hierarchy. The scope of any partial analysis depends on the nature of the diagram. If the user is working on a mini-spec or a state transition diagram, appropriate checks are made only on that one diagram and its corresponding entries in the data dictionary. If the user is working on a data flow diagram, that diagram plus any diagrams at other levels of the hierarchy below it and the data dictionary are analyzed.
The Model Analyzer verifies the executability of the model and generates the run-time description used by the simulation engine.
Foresight's simulator provides the execution environment for dynamic analysis of executable system models. Using the simulator, users validate the correctness of their system requirements and designs, exercise operational prototypes of their system, and integrate and test detailed component designs.
Foresight provides a highly interactive, discrete-event simulator used to fully execute the functional, behavioral, and performance characteristics captured in the system model. The simulator can be used for a broad range of dynamic analysis, ranging from detailed model debugging (using breakpoints, single-stepping, etc.) to long simulation runs for data collection (using the free run mode).
Figure 13 - Foresight Simulator Panel
Foresight's simulator control panel appears on the screen when the simulator is activated. Users control and monitor the execution of the system model through the control panel, which is shown in Figure 13. Its capabilities are described below.
Running Modes: A variety of options exist for controlling the rate at which the simulator engine runs, and its mode of operation.
Input Stimulus: The user can enter inputs to the simulator interactively via the input library elements. Alternatively, the user can construct Foresight models for automatically generating input data. The user can also prepare test case input files which are then fed into the simulator using the "Read from file" option.
Recorder: Various test suites may be quickly and easily developed. The simulator recorder function can be used to capture input and output data during simulation. With this facility enabled, all user-generated input events are captured to a file. This text file may be modified and subsequently be read back to provide the stimulus to the model automatically. The value of flows that are marked with a monitor (described next) may also be captured to a file to capture test data.
Monitor: During simulation, the user can select data flows to be continuously monitored. The flow name and its associated value are displayed in a special monitor window, which is activated by the user.
Breakpoints: The user can set breakpoints on any number of information flows. The simulator then pauses every time there is a new data token generated on the flow, allowing the user to view or modify the flow values. Breakpoints can be added or removed by graphically attaching or detaching the breakpoint.
Model Animation: Foresight animates model execution, which allows the user to view graphical highlighting of data propagation, process activation, state behavior, and state transitions on the diagrams. This is particularly valuable for model debugging and for demonstrations to customers or managers. Model animation can be seen by simply opening the desired diagram windows.
Incremental Compilation: Simulation mode can be turned on or off at any time. This allows the user to edit the model to correct errors or make changes or additions to the model in the middle of a simulation. After the design diagrams have been re-edited, simulation can be continued, with all state values maintained.
Partial Simulation: Foresight does not require all processes to be expressed in an executable fashion before simulation can begin. If desired, the designer can describe a process with an informal description. (This might be appropriate for a process that is difficult to model, but yet has a low risk factor.) While the Simulator cannot actually execute that process, it can still simulate the rest of the model. By abstracting the model, or using the forcing capability of the simulator to force data out of the unmodeled process, the designer can still exercise the rest of the model.
The simulator allows users to stimulate the model interactively through input library elements, such as slider bars, alphanumeric inputs, and selection buttons. Input stimulus patterns may be stored as test cases. These test cases can be reused throughout model development, as well as when the component designs are inserted into the system model for verification testing.
With Foresight, users can also model the system's context without any input library elements; users can model the system's environment and its interfaces with Foresight's modeling constructs and execute the model without any interactive inputs. Foresight gives developers the flexibility to execute and analyze their system in the most effective way.
For debugging the system model, users can set breakpoints, single-step model execution, attach monitors to information flows, and interactively switch between simulation and editing modes. Moreover, data and events may be forced into the model interactively.
For executing long simulation runs, the simulation can be put in free-run mode and monitored values may be stored to external files to capture test data and model statistics.
In addition to monitoring information flows, output library elements may be used to graphically and textually display model activity and results. Examples of output devices include a bar meter, display panels, and a strip-chart recorder.
Foresight's powerful simulator allows users to dynamically analyze system models. The simulator has a rich collection of capabilities for executing models - allowing users to ensure the correctness of their requirements and designs, perform architectural trade-offs, exercise operational prototypes, and test detail designs.
< Previous Page | Next Page>