Simulation Newsletter, Vol 1, # 1, August 1994

*********************************************************************

                           PARALLEL PERFORMANCE GROUP

                              SIMULATION NEWSLETTER

                                Volume 1, Issue 1

This is the first in a series of free bi-monthly Electronic-Mail Newsletters from Parallel Performance Group on Simulation software tools, as well as spec- ific state-of-the-art Simulation software products.

Parallel Performance Group specializes in the marketing and distribution of high-technology scientific and engineering software, principally to users of engineering-type computer workstations and software practitioners. Through this Newsletter, we hope to provide software practitioners and Simulation Pro- ject Managers with a more-than-casual insight into Simulation by presenting a survey of the state-of-the-art and tutorial examples of various applications.

THIS ISSUE'S TOPIC: SIMPLE ++ FROM AESOP GmbH, Stuttgart, Germany

Stuart Bar-On or Tom Beshaw of Parallel Performance Group, at (602) 282-6300, or E-mail at ppg@ppgsoft.com, will be glad to answer any questions you may have and provide more literature and information about SIMPLE++. To get an e-mail Newsletter subscription, send "Subscribe Simulation Newsletter" message to subscribe@ppgsoft.com.

Ease and Speed of Simulation with SIMPLE++

The widespread adoption of simulation has often been curtailed by the limitations of existing simulation software. Users expect an easy to use graphical user-interface and a high level of functionality to address a wide range of applications productively.

Despite vendors claiming to have provided the latest or the next generation of software, these have made little impact in the market place. Therefore the development objective of SlMPLE++ was to ensure freedom from the constraints inherent in existing simulation software. SlMPLE++ was first installed in February, 1992; many well-known European companies are using SlMPLE++ today.

The power of SlMPLE++ lies in the ease and speed of building, modifying, and maintaining simulation models. SIMPLE++ incorporates the advantages of various concepts such as building block, list, and language, in one product. Different and incompatible systems are no longer required.

APPLICATIONS

Examples of successful applications of SIMPLE++ exist in manufacturing, assem- bly, storage, and transport systems. Even entire companies and complex distri- bution centers have been simulated by SIMPLE++.

To support daily operations of a company, SlMPLE++ is used for prognosis, fine planning, and control. Order sequence, staff dispatching, stock, lot size, schedules, and costs are optimized, and production plans are continuously mon- itored and modified in realtime. Realtime data exchange and interprocess com- munication are necessary in this application.

SIMPLE++ DESCRIPTION

SlMPLE++ stands for Simulations in Production, Logistics, and Engineering, and its implementation in the programming language C++; it is the European standard software for object-oriented, graphical and integrated modeling, simulation and animation. SIMPLE++ is fully object-oriented: the graphical user interface, system architecture, and implementation all conform to the demands of object orientation.

SIMPLE++ offers a user interface for interactive and integrated operation, and does not have separate programs for modeling, simulation, and animation; each function can be called at any time. This feature is called an "integrated work- ing environment"

Modeling can be determined by the user according to his personal working style. There is no prescribed procedure; modeling is performed independently from the simulation. This is known as " non-procedural operation".

SlMPLE++ also offers "incremental operation". Any level of detail can be added, and complex structures can be simplified, as required at any time. This is very important in practice, since the permanent optimization of systems and business processes requires frequent modification of the model.

User productivity is significantly increased by the integrated environment, and non-procedural and incremental operation. In addition, one can build his own dialogue mask for each object. Complexity can be hidden, showing only rele- vant parameters to the user.

SIMPLE++ can be tightly interfaced with other systems. Important features are real-time data exchange with, and remote control of, SIMPLE++ by other software such as an MRPII system. The following interfaces are available: SQL Database, Interprocess Communication, ASCII file, Graphics, C, C++, and Operating System. These interfaces, and its functionality, make SIMPLE++ an open and totally in- tegrateable system.

All objects in the Object Template, all objects - Basic Objects and Application Objects - are visible and accessible. The Object Template can be configured by the user according to the specific application.

The Basic Objects of SIMPLE++ are classified as material-flow or information- flow. Material and information flow can be modeled independently. Material- flow Objects are machines, conveyors, stock, vehicles, paths, containers and parts.

Information-flow between objects is realized by information-flow Objects, such as controls, event generators, lists, and displays. These objects, the powerful control language SimTALK, and many functions, data types, and operators assure comprehensive information processing in SIMPLE++.

The user builds an Application Object by combining Basic Objects interactively. Once these are defined, they are stored in the object template so that they can be reused. Nesting of Application Objects enables hierarchical structures and incremental detailing of SIMPLE++ models which are modular, well-structured and accurate.

The SIMPLE++ standard configuration offers some sets of Application Objects: labor pool, standard controls, and automated guided vehicles (AGVs). Other sets of Application Objects such as those for the chemical industry or shop control are optional. These Application Objects are transparent to the user and can be adapted or used for reference.

Any object can be duplicated. This is not merely a copying process but inher- itance: the instance (copy) has a controllable relationship to the class (orig- inal). The use of this feature significantly increases modeling productivity and reduces errors.

Common control strategies are provided in SIMPLE++ by Control Objects. By combining these, most processes can be controlled without any programming. Complex and specific control strategies are defined by using the integrated, powerful, and user-friendly control language SimTALK. The user decides whether to use the Text Editor or the graphically guided Symbol Editor to define these controls. SimTALK is supplemented by a comprehensive Debugger to identify and correct errors quickly and effectively.

The Manager in SIMPLE++ controls the simulation. The user can program or interactively set the manager at any time. Simulation can run with or without animation. The state of a SlMPLE++ model can be solved at any time during sim- ulation interactively or as a programmed occurrence. Models can be preloaded with information or objects in order to start simulation at a predefined state.

Model information can be presented during simulation by digital or analog displays. Multiple parameters can be monitored concurrently over the simulation time. SIMPLE++ has a variety of standard statistics. Data can be collected and statistics calculated for any defined period of time.

Animation runs on-line with the simulation. The animation speed can be adjusted by the user from step mode through real-time up to top computer speed. Object pictures are changed during simulation state or event driven. This is important for model verification and enhancing presentations. Object pictures are created with the Graphics Editor, or simply selected from a picture template. A help function provides on-line documentation, providing instant, context-sensitive information.

SIMPLE++ INNOVATIONS

SlMPLE++ has three innovative aspects: software technology, product features, and range of applications. Fully object-oriented technology provides special features which can address a wide range of applications productively. Object- Orientation is a software technology of the future but becomes of value only if it provides benefits for the user. The most important advantages of object-or- ientation in the development of SlMPLE++ are:

- higher development speed and simultaneously better quality,

- optimal enhancements and ease of modification,

- extended model life cycle of product to protect the value of your investment.

In addition to the advantages of object-oriented software development, the following SlMPLE++ features contribute to the ease and speed of building, modifying and maintaining models:

during modeling, any part of the model can be simulated and validated independently of the whole. Even controls can be executed without running simulation. This is called an "integrated and object-oriented working environ- ment";
with the help of hierarchy, an entire company can be modeled to reflect real life. By nesting objects, the hierarchy is built dynamically and the model is detailed incrementally;
inheritance is very important in both building and modifying models. In SIMPLE++, inheritance is controlled by the user at the parameter level of each object;
SIMPLE++ provides application-specific object templates; the application ob- jects are built graphically and interactively from basic objects by the user. Because of the full object-orientation of SIMPLE++, all objects are reusable without modification; this gives modular and well-structured SIMPLE++ models;
integrateability and openness of SIMPLE++ are assured through standards and interfaces; features like real-time data exchange during simulation and inter- process communication are vital for integrated solutions; moreover, SIMPLE++ can be controlled totally by external systems like MRPII.

SIMPLE++ SPECIFICATIONS

User Interface

- object-oriented, graphical user interface

- all model information is graphically represented and accessible

- application oriented dialogue and plausibility check

- user-definable dialogue masks

- Screen control by Zoom and Scroll

- "integrated working environment": all functions for modeling, simulation and animation are available concurrently

- "incremental operation": allows one to increase detail or simplify the model as appropriate

- "non-procedural operation" modeling according to the user's preference and independent of the simulation flow

- on-line documentation

Modeling

- model size not limited

- detailing or simplifying of a model at any time

- Object concept: Basic Objects and user definable Application Objects template with Basic Objects for material and information-flow Processor, conveyor line, stock, vehicle, path, container, part, lists (2D, stack, queue, random), generator, controls, display and information objects

- sets of Application Objects for most productive modeling: control objects, staff pool, AGV's and material-flow objects

- picture template containing various pictures to represent objects in the animation layout

- individual and multiple animation pictures per object are changed event or state driven during animation

- graphics editor to define and change object pictures

- inheritance controlled by the user at parameter level

- unlimited model hierarchy and process structures

- fixed and free attributes for each object; all attributes can be processed

- independent modeling of material and information-flow

- unlimited independent Random Generators

- stochastic distribution of parameters

- flexible and powerful information management with more than 50 mathematical, textual and logical functions

- SimTALK object-oriented built-in control language

- interactive test and correction of controls without running the simulation

- Debugger to debug controls and support model validation

Simulation/Animation

- animation on-line to simulation

- animation on-/off-switch

- animation speed selectable: step-wise up to max. computer speed

- any preloading at the beginning and storing during simulation of the model

- remote control by external systems

- data exchange during simulation

- statistics for total simulation time, intervals and actual runtime: working time, preparation time, breakdown time, blocked, throughput time, capacity load (min/max)

- change of model and parameters during simulation/animation

- step mode to follow the simulation/animation events

- individual collection and presentation of model and simulation values

- free definition of the animation layout

- event-driven and interactive change of object pictures

- visualization of hierarchy levels

- digital and Analogue-Display of model parameters

OPTIONAL PRODUCTS

	SIMPLE+_ C, C Interface  
	SIMPLE++_C++, C++ Interface
	SIMPLE++_IPC, Interprocess Communication
	SIMPLE++_SQL, SQL Database 
	SIMPLE++_shop, Shop Control Model 
	SIMPLE++_gantt, Gantt  Charts  
	SIMPLE++_process, Chemical  lndustry
	SIMPLE++_GA, Genetic Algorithm

System Requirements:

Workstation or PC with UNIX and X-Windows/MOTIF, 16MB memory, 100MB free disk capacity, floppy, 256 colour graphics, with resolution of 1024 x 768, mouse and keyboard; serial interface for SlMPLE++ security device.

Released Platforms:

	DECstation 5000/ULTRIX
	DECalpha/OSF1
	HP 9000-4xx and -7xx/HP-UX
	IBM RS/6000/AIX
	Silicon Graphics Indigo/IRIX
	Sun SparxStation/SunOS or Solaris
	PC/SCO-ODT

Important SIMPLE++ Installations:

AEG, AlT, AKH, Alusingen, ARGUMENS, ARJAL, BARCO, BASF, Bayer, Bertelsmann, Biltons, Bloxwich, BMW, Bosch-Siemens, Bohrlnger Mannheim, BST, Buhler, BWl CIBAVision, CIM Cenfrum COM-SOL, Deutsche Bundesbahn, Eisenmann, ERMETEK, FORD, Gebhardt Fordertechnik, GEILINGER Engineering, GENIAS, GEROH, Growela, HACO, Haushahn, Hennecke, Hewlet Packard, HOECHST, HYPERION, IAO, IBM, IFF, INESC, ITT, i+o, IPA, ISC, IUCCIM, KM Kabelmetal, Kendall, Klumpp, Landys & Gyr, Lehmann + Peters, Levi Strauss, MANGSHH Logistics, Mannesmann, Mercedes Benz, MBS, MRCC, MTU, M&R Fordertechnik, NOKIA, NOVAGEO, Paschal, Philips, PEGUFORM, PREUSSAG, ratioprojekt, REMMERT, RSL, Logistik, Seitz Consult, Siemens, SOLVE, STORCK, SUSPA, TECNOTRON, TEG-S, CIM-TT, Unseld & Partner, VAW, VOEST, Wieland, Wolfel, WORTMANN....and many universities and institutes world-wide.

PARALLEL PERFORMANCE GROUP

SIMULATION NEWSLETTER

Volume 1, Issue 2

August, 1994

THIS ISSUE'S TOPIC: A New Approach to System Design - SystemSpecs

As engineers are faced with designing ever more complex systems in shorter development cycles, it is important to get system specification and design cor- rect the first time. This Newsletter describes the system specification, model- ing, and design tool SystemSpecs. SystemSpecs' output is the creation of exe- cutable specifications. SystemSpecs can significantly reduce design and dev- elopment time and improve the quality of the resulting system. Let's start with an overview of the tool and its optimized ANSI C/C++ code generator. The code generated is efficient enough to run on most popular microcontrollers without modification.

Stuart Bar-On or Tom Beshaw of Parallel Performance Group, at (602) 282-6300, or E-mail at ppg@ppgsoft.com, will be glad to answer any questions you may have and provide more literature and information about SystemSpecs and Sim- ulation software. To get a free e-mail Newsletter subscription, send "Subscribe Simulation Newsletter" message to subscribe@ppgsoft.com.

A New Approach to System Design

Traditionally, the specification of a new product has resulted in a set of documents whose usefulness was dependent on the authors' thoroughness and writing talent. Inconsistencies and ambiguities inherent in such an approach are often found in the implementation phase where they are very costly to correct. Starting in the 1980's, Computer Aided Software Engineering (CASE) tools produced specifications which were often less ambiguous and easier to un- derstand than those written in a natural language; however, CASE tools have a major drawback: they cannot adequately model a system's dynamic behavior.

To accurately model this behavior, the specification must be executable, and the methodology should be based on formal semantics. The capability to model dynamic behavior is essential in ensuring that a specification is complete and completely unambiguous. A methodology based on formal semantics enables system characteristics to be mathematically proven rather than determined through ex- clusive reliance on execution (which can never be exhaustive) to locate errors. Also, an executable specification is easier to communicate to the customer, as well as the marketing and production departments.

SystemSpecs offers the engineer an environment in which system models can be created, animated, simulated, analyzed, and prototyped. The methodology used is a synthesis of graphics and text, allowing definition of the static structure of a system, data flow, control flow, finite state machines, and dynamic beha- vior. A special strength of this approach is the ability to model sequential, concurrent, and asynchronous behavior. The methodology used is very flexible; it even allows use of other CASE methodology. For example, we show the Cruise Control example by Ward & Mellor [1] modeled by SystemSpecs. The diagram below shows this system's Context Diagram converted to a SystemSpecs SpecsNet. The data flow (dotted arcs) and control flow (dashed arcs) between the modules can be identified and animated.

                      Measured Mile                            Driver
                                                              ---------
                                     O<---------------------->|       |
                                     |                --------|       |
Engine                       Engine  |               |        ---------
_____                        On/Off  |         ------         . . | | |
|   |.............................>O |        |               . . | | |
|   |                              | | Cruise |    Start/Stop . . | | |
-----                              | | Contrl v    Incr.      . . | | |
  |                                | | On/Off O    Speed      . . | | |
  |                                | |  ______|     O<......... . | | |
  |                                | | |            | O<......... | | |
  |                                | | |            | |Resume     | | |
  |                                | | |  __________| |           | | |
  |                                | | | |            |           | | |
  |                                | | | |            |           | | |
  |                                v vvv v            |           | | |
  |  Brake Pedal                  _________           |           | | |
  |   ______                      |       |<----------            v | | 
  |   |    |-------->O----------->|       |......................>@ | | 
  O-->|    |    Brake    -------->|       | Maintain     Auto Speed | |
      |____|            |         --------- Auto                    | |
        |               |          ^    ^   Speed                   | |
        |               |          |    |                           | |
Brake   v               |          |    |                           | |
Release O               v   Thrtl. v    v                           | |
        |  ------------>@   Pos.   @    @ Throttle                  | |
        | |      Rotation          ^    ^ Control                   | | 
        | |      Rate              |    |                           | |
        | |                        |    |                           | |
        v v                        |    |                           | |
      --------                     |    |                           | |
Engine| Auto |<--------------------     |                           | |
  O-->|      |<-------------------------                            | |
On/Off--------                                                      | |
       ^ ^                                                          | |
       | |                                                  Pedal   v |
       | ---------------------------------------------------------->@ |
       |                                                              |
       ---------------------------------------------------------------O
                                                           Cruise Control
                                                            On/Off

Context Diagram of Ward & Mellor Cruise Control Example Converted to a SpecsNet

A net in SystemSpecs is called a SpecsNet, a carefully selected class of high level Petri Net. A SpecsNet is an intuitive synthesis of graphics to describe structure and concurrency, and a Pascal-like textual language (SpecsLingua) to describe data types and transformations. SpecsNets are built of four types of symbols: Places (circular), Tokens (dots), Transitions (rectangular), and Arcs (arrows). In the SpecsNet above, places unoccupied by Tokens are actually shown by the letter "O" rather than circles, and places occupied by Tokens are shown by the "@" sign, rather than by circles with a dot inside.

The Methodology

Places may contain data (a Token) of a certain type; e.g., integer. A Place is full when it contains a Token of the right type and with a specific value. A Transition can consume and generate Tokens; that is, transform data inputs in- to data outputs. Associated with a Transition is a program fragment with two parts: an optional condition and an action. The Arcs are labeled with variable names which may be referenced by the condition & action parts of the Transition to which they are connected. A Transition is enabled (and may fire) only when all input Places are full and all output Places are empty and the condition (if any) is satisfied; then the action will be executed followed by consumption of Tokens from the input Places and generating Tokens for the output Places. SystemSpecs allows system partitioning into subsystems (agencies) to construct top-down or bottom-up hierarchies.

System Modeling

System Modeling requires not only that a system model will be created up to a certain level of refinement, but also that the system's environment be modeled. This is particularly important for reactive systems where the behavior is defined in terms of reactions to stimuli from the environment. In practice, by simulating a system with its environment, a large number of errors resulting from incomplete, ambiguous, or even incorrect specifications are found and cor- rected.

In SystemSpecs, the environment can be modeled with Input/Output interfaces. These interfaces can be created either with the SystemSpecs interface builder, or by real hardware. The SystemSpecs interface builder allows the designer to create virtually any interface and connect it with a SystemSpecs model without writing a single line of code. Using hardware interface elements even allows an executing model to be embedded into these elements, so that they can be tested with their real environment.

For time-critical systems the SystemSpecs prototype generator with its as- sociated hardware allows execution to be speeded by a possible three orders of magnitude in comparison to simulation on the workstation. This allows prototype creation to be tested at a very early stage in the development cycle. Any spe- cification changes can be easily accommodated, when costs are lowest!

Design and Implementation

Once a system has been specified and modeled, the design and implementation phase can begin. SystemSpecs features a number of code generators for both hardware (VHDL) and software (C++ and ANSl-C). By refining the model and using these code generators, a system can be built very quickly. This is a major benefit in situations where time-to-market is important.

ANSI C Code Generation for Popular Microcontrollers

One can make a convincing case for the benefits of using SystemSpecs to refine a specification even if it were not used for the subsequent design and implementation. Indeed, projects at various companies testify to such product- ivity gains, particularly for complex systems; however, productivity gains are further increased substantially thru SystemSpecs' efficient implementation of automatic C or C++ code generation:

the generated code supports separation into tasks; this is done by generating a task for each "agency" in a net;
a simple yet safe inter-task communication is used that can be mapped onto virtually any multitasking kernel;
the code generator requires only minimal support from a kernel if more than one task is generated;
for single task generation no kernel services are required, just the normal processor-dependent support code (processor initialization, I/0 access routines);
the user can guide how many tasks the code generator will create for a particular net hierarchy.

Task Definition

The tough job in all traditional CASE systems is the creation of the task model. The user is left alone to decide how his system should be subdivided with no help from the system to tell him if a proposed task is sensible or not. SystemSpecs tasks are identified, and the model transformed, so that tasks cor- respond to sub-hierarchies. A task generally corresponds to a sub-hierarchy but it is suggested that the user define tasks using the recipe below.

A Task is a set of Transitions and Places that transform data from input interface Places to output interface Places (as seen from inside the task hierarchy). The task is controlled via a control-flow net (which may be inte- grated with the data flow), is tightly coupled, and has sequences and loops of fireable Transitions, but contains no parallel fireable Transitions (these be- long in another task). A task can access external data buffers (modeled with a double Arc to an external Place) and can generate new control flow Tokens for itself and neighboring tasks.

lt is possible, via animation, to easily see parallel fireable Transitions, to test for cyclic behavior, and to move net elements from one hierarchy (task) to another. If the user follows SystemSpecs' task definition, then SystemSpecs will generate high quality code. The code generator assumes that the kernel, if used, provides the following services:

1) task creation and task switching

2) semaphores to protect inter-task communication variables

3) signals (at least one per task) to awaken a task which has put itself to sleep when it could not do any useful work (in other words the generated code does not use polling).

The generated C code offers open interfaces to external tasks which can be used to include existing software modules and I/0 drivers . The structure of the code is such that any reasonable kernel can be supported via a small include file which translates SystemSpecs calls to specific kernel calls. SystemSpecs will offer specific I/0 drivers for each kernel/microcontroller supported.

In summary, the strengths of SystemSpecs especially when compared with tradi- tional CASE approaches are:

1) SystemSpecs uses only one type of diagram for the analysis, design, and implementation phases, in contrast with Yourdon with its Environ- mental Model, Event List, Context Diagram, DFD's, Decision tables, Flow Charts, Pre/Post Diagrams, Structured English, Nassi-Schneider- man Diagrams, Data Dictionary, and Entity Relationship Models;

2) SystemSpecs uses a formal model that can be analyzed to test for critical system characteristics;

3) SystemSpecs models can be executed, with or without animation;

4) the step from analysis to design requires only that the model be refined and not completely rewritten in another formalism;

5) To facilitate design, SystemSpecs can provide efficient automatic ANSl C or C++ code generation for popular microcontrollers with or without multitasking real-time kernels.

References:

[1] "Structured Development for Real-Time Systems", Volumes 1-3, Ward & Mellor

BACK TO

CES Departmental Library
Envis Homepage
CES Homepage
*********************************************************************