DE10026387A1 - Procedure for optimizing execution time for the implementation of state- or process-oriented models in real solutions - Google Patents

Abstract

In order to take topology into account in an appropriate manner when a model is converted, a flag is set when a marker enters a causal chain and re-set when it leaves. This results in a decision criterion for a program branch, ensuring that the chain will only be processed if a marker is located therein. Long causal chains can be divided into areas. Each area is provided with one such flag and is controlled thereby. The model elements are converted into SPS languages, during a transition for example, in the following manner: switching is processed only when necessary, said switching being dependent upon a program branch which occurs downstream from the switchability check . A whole range of other strategies exist, based on various characteristics of the model, the process represented in the model and the target platform. The choice of a strategy can, for the most part, be computer-assisted in terms of design time, running time (optional) and fine tuning (optional), or be manual (optional).

Description

The chain optimization (Ko), according to claim 2, is applicable to all images of a mo dells and can be used simultaneously with element optimization (Eo), according to claim 3 be, the strategies according to claim 5 alternating within a mapping, are to be used several times and simultaneously.

Ko assumes that coherent causal chains (unbranched sequence of model elements) in which there is no active (marked) state need not be processed. This is based on the fact that a change of state can only start from an active state. An active state is understood as a state which has a marker which can contribute to at least one change of state (switching a transition). Accordingly, only causal chains need to be processed in which there is a marking (set of all active states). The more model elements in a causal chain, the greater the savings effect. To coordinate the execution of causal chains, for example, as soon as a brand enters the chain, one or more flags (hidden state) are set ( Fig. 1 ( 1 )). The flag is used to decide whether the chain is processed or not. As soon as the last mark of a chain is left, the flag is reset (see example 1), which means that the processing does not take place. The flag used here is a variant of element management according to claim 4.

If several states can be marked in a causal chain, the flag can also be a FIFO or some other mechanism. The flag is used here only as an example.

An extension of this principle leads to an optimization network, the execution management of the actual control network.

From the point of view of increased performance, very long causal chains can have several co-flags ( Fig. 1 ( 1 )), each of which controls part of the entire chain, so that a saving effect is also achieved if an active state is in one Part of a chain.

Since the degree of optimization essentially depends on the length of the causal chains and possibly on the time that a causal chain is brand-free and the properties that the target language (e.g. jumps with dynamic goals), a calculation can be made (if necessary empirically), the result of which is Provides information whether a knockout from a chain is worthwhile or not. It can be used to map chains with and without knockout included.

I. d. As a rule, co-flags, even if they can be represented by model elements, are not in the Model explicitly stated, since they only take over the function of code optimization. Possibly. can help the explicit representation in software tools as an operating mode of these tools be rich.

An efficient variant, provided the programming language and / or the operating system and / or the Development environment this supports is that a predecessor element (when switching) all after follower elements, which then cause a change of state based on the model state can enter them in a dynamic list and remove themselves and possibly others from this list distant. The list contains all model elements that are processed based on the model state have to, or don't need to be edited, whichever is more beneficial. Often the Ver administration of the lists is very high, so that the benefits only come from a certain network size ben is. In this case, the flags can represent a pointer or similar mechanisms.

The upper program code (example 1) shows that only the program lines up to the RET command subject to constant editing, while the part from T2 to the last line is only processed, if the Ko-Flag allows it.

The lower program code is completely (every line) subject to processing.

The element optimization (Eo), according to claim 3, is essentially for SPS and SPS-similar suitable machining mechanisms. In addition to the model elements, you can use the for Status transitions are also responsible for statuses (magnifying glasses) and actions (IEC61131) and others Apply model elements. The individual model elements are structured. That is, the switching condition (or similar mechanisms) is determined by the switching action (or similar Mechanisms) separately.  

example 1 Illustration of the model from Fig. 1 with the PLC programming language AWL standardized with DIN EN 61131-3. top with Ko and bottom without Ko (the necessary variable declaration has been dispensed with) annotation

In this example, the causal chain controlled by Ko (short Ko chain) is always marked, if P2 is also marked, so that the saving effect only occurs when P1 is marked, but it is sufficient to explain the mode of action. Furthermore, more complex switching conditions have been considered omitted for the sake of simplicity.

The latter is only processed if the condition of the switching action and the so-called Switching (or similar) takes place. For example, with a jump distributor, one List or table.  

Example 2 Realized implementation of the model element T1 from figure (above with Eo and below without Eo) with the PLC programming language AWL, standardized with DIN EN 61131-3

Since the introduction of a program jump (program branch) towards switching operations and how which costs additional computing time back to the jump distributor, can a platform-dependent calculation possible optimization. This determines whether the model element is better linear or is structured. The decisive factors in such a calculation are the number the edges (edge: (Baumgarten, B .: Petri-Netze: basics and applications. Mannheim, Vienna, Zurich: Wissenschaftsverlag 1990. ISBN 3-411-14291: page 17) and their required computing time, the Computing time required for program branching (jumps). In unfavorable cases it can also be too a deterioration in the computing time required.

Thus, the mapping of the elements of the same model, depending on whether the linear or the structured mapping is faster, contain both mapping variants.

The entire network optimization (Ko and Eo) can also be represented as a tree structure, in the elements deeper levels through more control structures are managed (executed) than elements in higher ones Levels. Elements of the highest level are always processed.

1.1.1 Areas of application

Areas of application of execution time optimization for implementations of status or workflow ented models in real solutions, according to claim 1, are all automatons (term of automa ten or graph theory) and Petri nets (Petri net-like), which are typically mentioned, whose mode of operation is status or process-oriented, this also includes the models of IEC 61131, IEC 61499 and Grafcet. These are briefly called models in this claim. It is irrelevant whether a realization (implementation in a realized solution) in software or hardware goods, both or other implementations. However, it is particularly suitable for solving of software-based control tasks, which are carried out using a program generator and / or compiler or Assembler, interpreter, through a special operating system or runtime libraries (runtime) such as for example with a PLC (programmable logic controller) and / or processor-related language Chen, can be realized. The control tasks also include business management, Organizational or other control tasks. A source code (solutions) generated with Ao is accordingly, in particular the basis for a program, the processing time (time that a processor  needed to do it) is significantly shortened. This is especially true for the real time capability of Control solutions (automation technology) of great interest. The actually reached Ge The increase in speed depends on the topology of the model and ultimately on the choice platform (compiler tool, hardware on which the control solution is implemented, the selected programming language, such as C, Pascal, assembler, programming languages of DIN EN 61131- 3, such as STL, ST and possibly other).

1.1.2 State of the art and its problems

Petri nets (short: Netz or Petrinetz (PN)) have been around since 1962 (automaton theory already exists longer) than typical representatives of state- or process-oriented models for discrete processes knows. There are various variants and classes of theories, which are discussed in detail in various publications are cut. The theory finds practical, industrial use only in exceptional cases, although the Number of uses has increased in recent years. In control technology, these Mo delle can be used effectively regardless of the platform. One with the DIN EN 61131-3 strongly changed form of Petri nets since 1995 or 1993 (international) as the language of expiry (AS) or Sequential Function Chart (SFC) standardized.

The mapping or implementation of a model to a programming language has so far been done in a linear manner Shape. Linear form here does not mean that subroutine techniques are not used. Rather, it is Illustration according to a certain scheme that largely combines the model elements or the model Depends on the menu and does not offer structuring that results in improved performance. It two linear forms for model element mapping are known, one mainly works with spei saving and memory-clearing commands ([vA93]: v. Aspern, J .: PLC software development with Petri nets. Heidelberg: Hüthig (1993). ISBN 3-7785-2197-7, [vA94]: v. Aspern, J .: PLC software redevelopment: Petri nets and word processing. Heidelberg: Hüthig (1994). ISBN 3-7785-2279-5 and [F94]: Friedrich, A .: Successful automation with PLC. Poing: Franzis-Verlag (1994). ISBN 3-7723- 6813-1) the other with commands that essentially uses Boolean algebra and largely on storing and deleting commands are omitted ([A94]: Auer, A .: control technology and syn thesis of PLC programs. Hüthig (1994). ISBN 37785-2215-9 for example pages 135-137). The state of the art, although no published evidence is known, is Illustration of the model elements using so-called high-level languages (C, Pascal) Instructions. Here is already a structuring of the model elements by the platform given, this is not subject to the claim according to claim 3, insofar as this is a (the only) method of the programming language is. However, the Be Condition split into several sub-conditions the claim.

It is also known that the representation of causal chains ([vA93], [vA94], [A94] and [F94]) by An Sequence of the program code of the chains without additional checking of the necessity general processing. Here, therefore, the image is subject to high spoke according to claim 2 of the claim.

Hardware-based solutions are in König, R .; Quäck, L .: Petri-Netze in control and digital technology. Munich and Vienna: R. Oldenburg Verlag (1988). Find ISBN 3-486-20735-0.

Two aspects or problems lead to the unnecessary extension of the processing time by processors with linear code generation, which work together or individually depending on the platform.

• 1. Models shown in a linear manner are usually completely removed from the processor system (entire model) worked, whereby the causal structure of the model topology is not taken into account. A state Changes in a model can only take place on active states (marked states). Just longer causal chains or parts of such a causal chain that are not currently active the current program execution, therefore do not have to be edited what the linear representation of the model not taken into account.
• 2. PLC platforms (e.g. STL from DIN EN 61131-3 or the PLC language Step 5® (STL) from Fir ma Siemens®) or similar mostly edit the code line by line. That is, that shown Model elements ([vA93], [vA94], [A94] and [F94]) that often have an execution condition (generally called shaft condition here), and one dependent on it part to be carried out (here generally called switching action), completely processed, although this would only be necessary for the switching action if the switching condition is fulfilled.

The invention is described in more detail below with the aid of further illustrations.  

1. Optimization 1.2 Optimization, what is it?

The process of a targeted selection, a targeted design, or both instruction sequences zen, algorithms and data or data structures for generating small, fast programs Optimization.

Significant for the selection of compilers and code generators can be the ability of automatic Optimization taking into account target system-specific features (hardware, operating system, Runtime) and properties of the respective language (graphical, textual). Straight through the north Using the PLC languages, providers are always looking for differentiation features of their pro products to those of the competitors. The power of automatic optimizations is a useful one Differentiation, above all, comparable, without great discoloration of marketing, if there are uniform benchmarks.

Aspects of optimization must also be considered by the application programmer. He is with us often on manufacturer information regarding the processing times of operators in connection with be agreed data types, interfaces, addressing scheme, memory requirements and others rem instructed. However, manufacturer information is rarely found. Unfortunately, often only exist general and general information that has only a very limited suitability with regard to a have precise analysis.

Efficient optimization must be understood as a continuous process accompanying development. Optimization efforts at the end of development are often more complex and less effective. Optimization is both science and art. Science presents methods of optimization, and art is mastery and efficient use of methods. The optimization goal should be determined before the start of development. The general objective is clear
the reaction speed (real-time behavior),
the communication effort (bottleneck fieldbus), as well
memory requirements (program and data),
for controls and additionally for applications with a visual surface in
the display speed (speed of screen construction),
the subjective speed (effect on the user) and,
the memory requirement for graphics.

Unfortunately, optimizations of one feature often work at the expense of the other. It rarely exists Possibility to optimize all features. For example, the optimization of the bear often has an effect processing time unfavorably on the memory requirement. Reduce or speed up the application can also reduce transparency by generating compact but difficult to read codes. A clear objectives help to decide the contradictions of the optimization procedures.

Time is money. This also applies indirectly to programs. Is the source designed so that it is minimal Computing time takes up more space for the implementation with the same computing power rer tasks available, or the reaction speed increases. With increased reaction speed, however, an increased output of the automatic production may also be achieved, what can be read directly in the business indicators or one or a faster one System reaction in dangerous situations. Ultimately there is another argument, of which the whole industry lives and that speaks for an optimization. What is meant is psychology or advertising, which triggers the good feeling of security, because the consciousness exists, the task to have solved outstandingly. The constantly increasing performance of modern processors is probably the cause of the Considers system resources (program and data storage, logical program length, etc.) to be to use it wastefully, and thus the miserliness can be attributed to the past. Not for cost reasons, each controller can be equipped with generous resources. Just think there on small and very small controls. Modern automation concepts include distribution the controls and the I / Os in the field. Multiple communication interfaces are becoming increasingly common (Fieldbus, LAN, WAN) in operation simultaneously. The communication effort increases significantly. The be the processor must provide the necessary computing capacity. Furthermore, modern Applications with a significantly larger data volume, as some tasks (quality assurance, Logging) have also been relocated to the PLC and, last but not least, are made up of different Reasons (data collection for statistics, historical data) collected more data than was previously the case. Last but not least, the data types used are becoming increasingly complex. Sufficient a few years ago still BOOL and BYTE, STRING, REAL and date and time types are more and more common today  for use. In general, the effort for optimizations should not be underestimated. In addition to the Effort estimation is the strategy to be used as a risk factor.

Powerful tools that automatically suggest suitable strategies and possible fine adjustments allow gene are helpful here.

1.3 General information on optimized code generation

In the foreground of the analysis for code optimization, codes are to be localized, the high efficiency can be expected. Optimizations are inefficient and pointless, they are also extremely effective, de processing is seldom done. This applies in particular to codes with time-dependent off leadership control and at the same time large intervals (e.g. 2 hours). The optimization is effectively there, where it is possible to achieve the greatest possible improvement with minimal effort.

1.3.1 Speed optimization

The lines of code, which are run through more often than others, such as Loops (interactions: e.g. FOR, UNTIL, etc.). However, more runs also arise for code sequences that are not hidden using selection constructs (selections: e.g. IF, CASE, etc.) are. For loops with many interactions (repetitions), the multiplier effect applies to every one saving.

The following applies to code segments in the loop body:

Lines of code that do not necessarily need to be repeated do not belong in the loop body. Block calls that appear harmless should also be examined in this regard, as they may be hidden a lot of code behind this. Complex calculations can often be broken down into an interdependency and disassemble an independent. The independent part is outside the loop body. His The result is cached. The union with the loop-dependent part takes place in the Fuselage using the variables instead. If block calls (FB) are unavoidable within loops, the parameter transfer can also be divided into an interdependent and an independent part disassemble.

There are often native data types. These then have speed advantages.

Often a basic statement in the form of a ranking of the processing speeds for Data types exist. Integer operations take less and less computing time than glide comma operations. To achieve the avoidable accuracy of the decimal places, is done the representation and interpretation of the integer value as a multiple (kilo, mega) or as a fraction part (milli, micro). Because of their design, processors use addressing schemes. Spei Access to the processor in its own format offers speed advantages. Direct memory access (% M...) Should, if not mandatory, take into account the addressing specifics of the processors (for example, only even addresses or divisible by 4).

Improvements are also possible with regard to arithmetic calculations. The exchange of one Multiplication by two by a shift operation by one bit usually has advantages. Absolutely too Avoid arithmetic calculations that consist only of constants and literals hen (INT # 10 + INT constant 15). The result is much quicker to design manually at design time average and just insert the result into the code.

In general, recurring calculations or parts of calculations should only be one Times to be carried out in order to buffer the results in variables. This makes it easier Maintenance and increases performance, since variable access is often significantly faster than calculations gene.

There are system-specific differences in the processing time of constants and Va reasonable, should corresponding knowledge influence the coding. The same applies to data with temporary or static.

The choice of interface can also be important. For example, the VAR_IN_OUT section Depending on the implementation, put a pointer to the actual variable or a multiple data copy (VAR_INPUT and VAR_OUTPUT).

Knowledge of the effects on the timing of the principles of overloading and typing Operations and parameters can be used.

Table 1.1 provides an overview, although not with claim to completeness.  

Table 1.1

Possibility of optimization to improve execution speed

1.3.2 Compact code, minimization of data storage

In contrast to many IT applications that require extensive hardware resources, these are often very limited for controls. For housing extensive functionality on limited Resources require the compactness of the executable code.

Compact code often depends on the choice of language. The generation of executable codes from graphic languages (LAD; FBD, AS) and high-level languages (ST) often use intermediate variables that the Stay hidden from users. However, when using STL, the developer checks the code and memory requirements.

Compact code is also created by reusable building blocks. Your code only exists once even with multiple calls.

Measures supporting compactness are essentially based on the removal of unnecessary codes. Sometimes this is difficult and time-consuming to find. The development system should offer appropriate services. Functions such as are desirable

• - find unused variables,
• - locate code sequences that occur several times,
• - Tracking down dead instructions (instructions that due to logical errors can never be used Execution),
• - Analysis regarding too large string declarations (maximum string size 45 characters, all However, string variables are declared as STRING [150]),
• - Detection of variables that are used only once (indication of unnecessary code) and
• - Determine unused data elements in arrays, structures and enumeration variables.

IEC 61131 sees a sequential memory allocation for multi-element variables individual elements. The same applies to instances (programs and function blocks), they manage  their data basically like structures. Variables of different types are often excluded areas (RETAIN, NON_RETAIN), some classes (VAR_GLOBAL, VAR_IN_OUT, VAR_TEMP) and localized variables. Taking into account the addressing specifics (only even addresses or by 4 divisible) processors can lead to considerable memory waste. Often offers sorting the declaration order of variables within the POU and the elements in the Structure type agreement improved memory usage. The sorting is done in groups. Ent neither all placeholders with the same memory requirement (1, 8, 16, 32, 64 bit) are combined or the arrangement is such that a largely complete memory allocation arises. In particular especially here, as for some other optimization suggestions, detailed system information of the provider required.

Without affecting the compactness of the executable code, as it is automatically removed by the compiler, are the lengths (number of characters) for identifiers, blank lines, spaces between the syntactic characters elements and all comments. So there is no reason to be stingy here.

1.3.3 Improve communication behavior

In the past, the limits of what was realizable often arose from the performance of the Control processors. Today, the performance of fieldbuses is becoming more important than bottles neck in the foreground. The mechanisms that different bus systems use are diverse. Optimization options are largely defined by the fieldbus concept. The Often the user only has to reduce the data volume by minimizing communication to achieve cation effort. The decisive factor is the chosen project structure of a decentralized car system that leads to a reduction in the number and size of the transmitted data leads.

If there is a choice between polling and event processes, the event process is often, in particular suitable for data with acyclic and large change intervals. Only with actual changes The data are transferred in an event-oriented (event) procedure Data. Cyclic pollen, on the other hand, transmits data at intervals without taking into account that the data is already available in the recipient on a large scale, as it is unchanged from the sender. Transmitted data, resulting in data packets, with adaptation to the specific packets of the communica cation system, are constricted, increase the data throughput. Transfers a system For example, a maximum of 8 bytes per message is required for 64 bits, for 65 bits against two. The improvement of communication behavior with a reduction by one bit, so possible from a distance is obvious.

Further optimization is provided for event systems, provided there is a corresponding possibility of influence consists in the data together with approximately the same change intervals in the same data packet are quantified. Data packets whose data rarely experience a change in value are thus separated from Data transferable with faster change cycles.

An information analysis is the basis for the discrete transmission of information from analog basic data. The Investigation targets the actual information needs. Must have the analog value on the receiver side characteristic information is available or sufficient. For example, if the sender has the analog information of a brightness, a receiver should react depending on a fixed size (e.g. 200 lux), it is sufficient only to achieve this size and not to transfer the size itself This reduces the data transmission from possibly 16 bits to one bit. Increased Ease of maintenance is also always given when there are several recipients of the discrete There is information and the threshold value (200 lux) changes frequently.

1.3.4 Automatic optimization

With automatic optimization, the compiler implements standardized optimization strategies. It has already been mentioned that some optimizations are not desired or lead to the deterioration of other properties. The integration of control mechanisms that influence the translation process should be part of the user support provided by the system. These control mechanisms are also referred to as compiler switches. Compiler switches that affect the translation as a whole have a global effect for all components. The targeted use of certain translation modes requires the compiler switch to ensure the switchover directly in the source. The 2 ^nd Ed. IEC 61131-3 defines the pragma as an implementation-dependent property without specifying an explicit syntax. The pragma basically allows the required function of the compiler switch, but is not standardized and allows additional tasks.

Good compilers should offer at least some automatic optimizations. In addition to the ones discussed in section 1.3.2 , the following automatic optimizations are helpful.

Save multiple literals and constants only once

The property of literals and constants, no changes over their lifetime Allowing content allows literals and constants that occur more than once to be used only once to save. This is particularly useful for memory-intensive data types such as strings and 32-bit Data types or, in the case of very frequently occurring literals and constants. For example, has an application oodles of timers, whose time value is identical, it is sufficient to to store the identical time value once.

Replace multiplications with shift commands

This optimization, which is proposed under section 1.3.1, also allows automatism.

Data type optimization

PC-based control systems or the used processors do not have fast bits operationsunits. The result: bit operations are slow. Significant increases in speed are accessible if the compiler stores each Boolean variable in the native data type (e.g. Byte, word, integer). On the other hand, the possibility must be optimized with regard to the memory requirement be given.

Data alignment according to the addressing scheme

The memory management, which takes over the addressing of symbolic variables, should address specifics (only even addresses or divisible by 4) of the processors under the aspect Ge Consider speed and memory optimization.

Remove dead code

Dead code should be recognized during translation and should not be included in the executable code. The body of the following IF statement is clearly dead. IF FALSE THEN. . .Hull. . .END_IF.

Building block integration

Blocks that are not called have no place in the executable code.

Unused variables

The same applies to declared variables that are not used in the source. They are also to be selected animals. The detection of unused elements is more difficult, but not impossible, to be derived and compound variables. This includes array fields, structure elements and values of the Auf count types.

Depending on the system and the task, further optimization measures are conceivable, so here there is no complete picture of all strategies. A critical examination (or questioning the Manufacturer) of graphic languages with regard to optimization is always appropriate. Often trans a code generator forms the graphic network in STL. There is often room for optimism here recognizable. In addition to the general and model-independent improvements presented possibilities, the following sections aim at optimization strategies, process and status theories tated models, such as Petri nets, SFC, Grafcet, state machines, machines and partly IEC 61499. These models are characterized by excellent properties of thickness, real pro processes, simply to map through states and their transitions. In particular, it hides status-oriented mapping great optimization potential in itself.

1.4 Optimization for process and condition-based models

Especially due to the topology of the networks (Petri networks, SFC, Grafcet, state machines, automatons, IEC 61499) (even if optimization is not supported by an SFC tool, for example, the Users themselves through appropriate concepts when designing transition and action air pen), which assume certain (marking) states, there are a number of possibilities Possibilities to minimize computing time. Common to all is that the Netzele elements (here essentially transitions, but also actions or magnifying glasses) depending on the Register or deregister marking for processing independently, or deregister from other network elements or be registered. Furthermore, a network element itself or its processing time, in particular especially if it is implemented in STL, in one case or another it will be significantly shortened. It occurs a reduction in the logical program length. As a result, the program increases extent (memory requirement and number of lines).

An ideal optimization would be found if a system automatically, without additional effort, recognizes switchable transitions based on active steps and only processes them. Then that would be percentage improvement the ratio of the time consumption of switchable transitions to Sum of all transitions in a network. For example, there are two switchable transitions in a network of 100 similar transitions. The processing time would then be a factor of 50  faster (corresponds to an improvement to 2% of the non-optimized time consumption). Are real however, as mentioned, to include additional management commands, so this factor is very is to be understood theoretically.

Which strategy of minimization is to be used, and thus the degree of minimization, depends depends on many factors.

The main factors are:

• - Command execution times of the platform (processors and runtime environment)
• - Features that the target language of the coding offers (e.g. dynamic jump targets)
• - Frequency of processing (actions twice, transitions once)
• - Frequency of switching or non-switching of transitions
• - Number of standard pre-edges, other pre-edges, post edges, extent of others Switching conditions, scope of the instruction block
• - Period of time that fulfills or does not meet a partial condition of the switching condition (strongly below different, almost the same) (time interval between fulfillment of a subcondition and fulfillment of the whole condition)
• - Number of brands (one-brand network)
• - meshing
• - Length of unbranched chains
• - Probability of the brands to stay in (sub) networks and chains
• - Number of marks in a straight chain
• - Position of the transition (front, middle or back) in a straight chain or in one One brand network
• - Time required for switching or not switching
• - Number of parallel transitions during processing to the total number of transitions
• - degree of causality
• - Dead networks or dead subnetworks (BK e.g. initialized)
• - Degree of conflict (as small as possible with dispatcher) as small as possible
• - Number of conflicts (as small as possible with dispatcher) as small as possible.

These are so many parameters that minimized implementation solely through the thinking of the Developer and not justify the time required. An analysis of this complex Connections should be done using software. D.H. the compiler must have a corresponding Generate code.

In many cases, a calculation can decide which minimization strategy or combination strategies are suitable, in other cases the user must provide additional information Support or refine the selection of the right strategy. Processes are also conceivable In trial operation, i.e. at runtime, examine the network model for dynamic specifics. The so ent Standing data collection serves as the basis for the determination of appropriate strategies. Especially the latter is usually not necessary for the majority of processes. The above calculation from the To technology, supported by the fine-tuning of the developer, generally offers one sufficiently good result.

1.4.1 Basic optimization principles

Usable potentials for minimization are based on the following considerations.

Control systems (PLC) process their programs so quickly that their sequential processing for the outsider (process to be controlled) acts like parallel processing. That is, that in Process the ratio of concurrent events to the sum of the possible process events This is often significantly smaller than the ratio of the PLC cycles without change of state to the sum of PLC cycles with status change. In other words, most of the time there is a lazy transition around in the processing loop of the program. She rarely works, namely during the Switching. Of course there are exceptions, some transitions switch more often.

It is therefore obvious to remove the idle transitions from the processing loop, or a restriction to reduce their processing to a necessary level (only ready to switch check shaft).

Additional commands must be added for this project, so that the number of program lines increases and a little more data storage may be required. These extend the individual command lines quenz such that either the switching or the non-switching is affected. The entirety of Program processing is significantly shortened, however, since either switching or non-switching Transitions are in the majority. The logical program length is shortened. A wide one re consideration is that the source of the switching action and possibly parts of the switching condition  are skipped as soon as it turns out when checking part of the switching condition that the Transition does not switch. For example, there is generally a Verrie in transition conditions success met. However, it is often not fulfilled in error situations. Thus, the lock can be used as last checked. This results in a shortened for non-switching and for switching a slightly longer processing time. This is exactly what is desired, since not switching Transitions generally occur much more frequently than switching. Keyword: "lazy Transiti on ".

Depending on the type and influence of the above. Optimizations between 98% and 50% can be achieved.

There are three basic strategies:

• - Depends on the element: The decisive factor is the scope (number of pre-, post-edges and the pro gram lines for additional condition), as well as the resulting computing time of the Systems
• - Process-dependent: The decisive factor is the shortness of the time duration, the individual signals are fulfilled before switching (last signal)
• - Topology-dependent: unbranched chains, single-brand networks or subnetworks, dead networks or subnets, etc.

To use all potentials, combinations of all strategies are used simultaneously, individually and more fold for mapping (coding) a network on a target system, using all sy stem properties, applicable.

1.4.2 Key figures

As some systems (common practice) for networks (IEC 61131, IEC 61499, automats, Grafcet, etc.) and In the following considered cases, Petri nets encode in STL are as follows Considerations are also made as an IEC 61131 figure.

In order to make comparisons of the effects of different strategies, a uniform reference value must be given. The time (switching or not switching) that is necessary for processing a linearly coded network or a linearly coded transition is suitable. Characteristic of such a code is the waiving of program branches (conditional jumps) behind the partial conditions of the switching condition or the switching condition as a whole (see example.... ???). The passive relationship is therefore of particular interest; occasionally the active relationship can also be of interest.
Passive ratio = NS _{test object} / NS _linear and active ratio = S _{test object} / S _linear
NS _{test item} Time for processing the non-switching of a test item T _test
NS _Linear Time for processing the non-switching of a transition T _Linear which corresponds to the test object T _test , but is linearly coded.
S _DUT Time for processing the switching of a DUT T _test
S _Linear time for processing the switching of a transition T _Linear that corresponds to the test object T _test , but is linearly coded.

Transitions that have more than one program branch within the switching condition then also have a correspondingly large number of places in the code where non-switching may have been detected becomes. So there is a minimum, a maximum NS time and generally some intermediate values. These are calculated in the Excel table on the CD for the book.

It is usually only marginally of interest how the active / passive ratio S / NS (AP ratio) changes. This ratio is always 1 for a linearly coded transition.
S Time for processing a switching transition T _n
NS Time for processing a non-switching transition T _n

1.4.3 Transition and its extended conceptual world

Known network classes extend the basic properties of the terms introduced by spe specific definitions. The most common are class-specific definitions for the terms switching rule, Switching readiness, switching action, liveliness, deadlock, security, conflict, etc. to find. Around There are a few to conduct the following discussion with a clearly defined basis Definitions of known and new terms. As far as necessary, the elements are one term assigned in Table 1.2.  

Table 1.2

Terms and their network element

Ready to switch (weak or insecure)

A transition is ready to switch when all the previous locations are occupied by a sufficient number of brands are so that switching is possible. (General: switching does not result in negative closes stands). The strong or safe switching rule requires that the switch is ready for switching Provide successor places with sufficient capacity to accommodate the brands. This behavior is provided here selectively by the special edge.

Extended switching readiness includes z. B. the pre-edges, PLC input or POE inputs (also negated), query (negated) of places and special edges. It is fulfilled when all of its edges are met are.

Conditional switching readiness includes other conditions including special switching conditions called (comparisons, time conditions, etc.).

Switching rule (convention rule) Switching condition Check the switching condition

Checking the standard pre-edges (activation of the transition). Fulfilled: Corresponds to the readiness to switch
Checking other pre-edges (release of the transition by other pre-edges). Fulfilled: Corresponds to the extended switching readiness
Check other conditions (conditional release of the transition through other conditions). Fulfilled: Corresponds to the conditional switching readiness

Switching operation

Switch when:
Switching = switching readiness & extended switching condition & conditional switching readiness then
Edit instruction block of specialized transition (delete, instruction ...)
Execution management (management of variables for optimization)
Clear the previous places (input or entrance places)
Occupying the successor places (output or exit places)

Switching ratio (SV) of a transition indicates the ratio of the frequency of switching to skin ability of not switching. The sum of non-switching and switching results in the number of ge Complete processing of the transition (or the network) or the source that represents the network.

A transition that never switches (is usually nonsensical) has a switching ratio of 0.

A transition that switches just as often as not has a switching ratio of 1. A transition that switches less than non-switching has a switching ratio of 0.5.
SV _T = number of switching / number of non-switching basis: transition processing
SV _N = number of switching / number of non-switching basis: network processing

The most important strategies are presented below. Combinations and other structures conditions are possible and useful.

It should also be noted that the instruction block and / or the switching operation or even all of them Transition (SpV-coded) can also be accommodated in its own program modules. For IEC 61131, however, this is currently not recommended because the mandatory data encapsulation for POE enforces additional instructions of parameter passing. This can be done in individual cases to be useful; in general, however, the need for computing time is rather too great.

It is suitable to implement the switching operation or the associated instruction block using Un Programming techniques, provided that they completely or partially forego data encapsulation, such as this support some environments. The program is a well-known representative of such a technology building block of the Step 5 syntax. In cases where identical or possibly largely identical claims Instruction blocks with several network elements (e.g. transition) occur are encapsulation-free construction stones are particularly suitable (e.g. extinguishing transition).

For the coding of transitions, the following PN-oriented is used for simplified discussion Naming parts of code.

The switching condition consists of codes for the implementation

• - the pre-edges, which only connect places with transitions (actual condition the classic readiness for switching (possibly including the special edge)),
• - the pre-edges (signal pre-edges), the representatives of PLC and POE inputs and represent separate queries of places and
• - one or more additional conditions.

In the following figures, the 3 source parts of the switching condition are designated with conditions 1 to 3. A further division in the given individual case is possible and may make sense. The switching operation consists of code for the implementation

• - the mail edges,
• - Prekanten, which only connect places with transitions and
• - The instruction blocks of the special transition types, such as delete transition, instruct sung transition, condition transition

In the following figures, the source part of the switching operation through the box is titled with "Switching action" represented.

Depending on the network class and type of transition, parts may be omitted and other source parts may also be required to come.

Many variants are conceivable for the coding, which are useful in one case or the other. Therefore, the following flowcharts each show the variant that gives good results by default supplies. Variants could, for example, the first, second or all conditions (1-3) to one summarize, or the last program branch (last condition) immediately before the Omit switching operation, etc.

In general, it is not absolutely necessary to assign all network elements to the same optimization strategy subject. It can be the best for each network element or for each part of a network (unbranched chain) Strategy or the best combination of strategies.

1.4.4 Appropriate strategies for control systems

The above-mentioned properties of the network, the process and the platform are suitable for the choice important. Some strategies require certain properties of the target language. This who supported by the STL. Furthermore, AWL is an efficient language, at least what opti affected code. Therefore, most of the examples and considerations refer below STL code. Few exceptions are high-level language constructs like If-Then, Case and others, underlying.

Transformation of the coding suggestions from STL to ST follow a simple rule: jumps are to be replaced by IF instructions. The logical relationships are specified in the STL to be transferred unchanged to the ST syntax.

Table 1.3 provides an overview of the strategies discussed below.  

Table 1.3

Overview of strategies

1.4.4.1 Strategies for optimizing network elements

Network elements are all elementary elements from which a network can consist, such as nodes (space and transition, edges, task, action, step magnifiers, etc.

1.4.4.1.1 Optimizing Boolean Equations

Every command that is in the source requires computing time if it is in the current processing loop lies. In particular, command sequences in repeat instructions of a critical loading subject to consideration. Basically, any command that is not necessary must be removed. First there are suitable minimization methods that besides minimizing the Boolean equation as well its processing time is shortened because the required commands are reduced. Are common but transition conditions of a simple kind and consist of a few links, so that one further minimization is impossible or not economically justifiable.

Without endangering the logical content, however, a further reduction in required rakes can be achieved time. The success of the procedure presented below depends to a large extent on the Processing time for individual commands that a target system (processor, runtime environment, Codie execution of the executable code) and may also mean deterioration. In In each individual case, it must be determined whether the benefit of the coding measure is given. This can be from depend on many parameters, as mentioned in the section on errors! Reference source could not be found that will. discussed.

Elementary operations are the AND and OR operations, which are essential for education of transition conditions.

Execution time-optimized coding of an AND operation

An essential feature of an AND operation is that for a TRUE statement at the end TRUE is also required for all inputs. Conversely, this means: Just introduce FALSE input, the result must also be corresponding. That is the decision already determined by a signal and an implementation with one jump per input given.

The following transition condition with 4 variables is implemented with jumps. Positive effects on the machining speed can only be expected if the partial conditions (E1 to E4) are correspondingly extensive and the additional jumps take less time.
Condition: E1 AND E2 AND E3 AND E4

Table 1.4

Transition condition and AND operation coded according to the wired-and principle

Is the link result in the sense of a complete AND link to a variable 2 measures are required. Instead of the switching action, the assignment is (TRUE) the line ST result. In addition, the following lines LD FALSE and ST AND result are direct in front of the code. The formation of the result is equivalent to a wired-and-ver creating an electrical circuit.

Execution time-optimized coding of an OR operation

An essential feature of an OR operation is that only one input TRUE is required for a TRUE statement at the output. Conversely, this means that if only one input is TRUE, the result must also be TRUE. This means that the decision is already determined by a signal and implemented with one jump per input. The following transition condition with 4 variables is implemented with jumps.
Condition: E1 OR E2 OR E3 OR E4

Table 1.5

Transition condition and OR operation coded according to the wired-or principle

Is the link result in the sense of a complete OR link of a variable 2 measures are required. Instead of the switching action there is the assignment with the Lines LD TRUE and ST result. In addition, the following lines are LD FALSE and ST ORER to put the result right before the code. The formation of the result is equivalent to a wired OR linkage of an electrical circuit.

Solving complex Boolean equations

Complex Boolean equations can be divided into the so-called conjunctive or disjunctive Nor Transfer painting form (KNF or DNF). Therme arise, which are either AND or OR ver are knotted. Thus, the principles mentioned above are in the sense of wired-and or wired-or-er links applicable to the thermal baths.

1.4.4.1.2 Special features of the IEC 61131 coding depending on the implementation

The IEC specification for STL does not contain any stipulations on the behavior of the current result (Formerly Vke - Linking Result -) after a jump. Depending on the implementation, it can, as in explained below, different arrests of the PLC occur.

Jumps

• 1. If the jump is not carried out, the AE, which is determined directly before the jump, is behind available for the jump. In the case of JMPC this is AE FALSE and in the case of JMPCN it is AE TRUE. An LD operation does not necessarily have to be behind a jump.
• 2. The first instruction at the jump destination must be an LD operation (restriction compared to the IEC).

Examples

brand

brand 1.4.4.1.3 Linear coding

Linear coding is the standard coding. A special feature is the time it takes for that Switching is just as long as that for not switching.

It is suitable for a reduced use of computing time only in the case of a transition that switches almost as often as not switching, or if the switching operation takes as much time or less than the necessary additional commands from the other optimization solutions, whereby there is often only one condition .
[see Fig. 1.1 Flowchart for linear coding of transitions]

1.4.4.1.4 Separate coding (splitting)

The splitting breaks down the complete switching condition into partial conditions. This works with the coding Linking result of each subcondition to a jump that if the transition condition is not met processing ended.

The non-switching of a transition T _n is considerably shortened by the fact that behind a partial condition a program branch (conditional jump) decides whether the next transition T _{n + 1} or further program lines of the transition T _n are subject to processing.

The splitting could almost be understood as a decomposition of a transition into partial transitions. Each sub-transition actually only represents a sub-condition (see.).
[see Fig. 1.2 Schematic representation of the splitting]

The separate coding is easy to implement and can be automated or manual if necessary. The size of the time gain in processing time is essentially the number of channels depending on the extent of the additional conditions and the delicacy of the separation. In Border areas are also the time that is needed for the additional jumps, to determine if this type of coding is advantageous.

In some cases, the order in which the individual conditions of the switching condition in the Source placements are important. Automatically generated code should choose an order where the partial condition runs from the shortest processing time to the longest. Of this is if necessary, deviate if this would require additional brackets. This principle can be applied to everyone other strategies, which are discussed below, can also be used.

Table 1.6

Splitting coding for transitions

[see Fig. 1.3 Flowchart for separate coding of transitions]

1.4.4.1.5 Jump distributor coding

The jump distributor (SpV) first introduces a virtual place (transition flag) for each transition. What first of all costs additional computing time. The saving effect is achieved in that in principle, only the higher-level branch distributor is processed (i.e. 2 instructions per transit on; Flag query and jump). Only the transition whose flag is set is subject to the others Check the switching condition. In principle, the separate coding can then also be implemented be mentored. It is therefore not mandatory to use the linear coding principle.

If the transition is not switchable, there is a return to the jump distributor. Just in case there are 2 variants. a) after switching back to the SpV and b) the Check the switching condition of the subsequent transition. However, the latter only makes sense if the after subsequent transition may become switchable by switching its predecessor transition. Under the control of a single jump distributor enables the possibility of joint transit encoding of both variants.

The switching action of a transition in the jump distributor must reset its flag and the flags of the Set successor transitions that become switchable by switching according to the network topology could. These are all transitions that have a successor position to the switched transition as before own a walker place.

SpV-coded transitions are always used in combination with a higher-level SpV.

Network topology requirements may also result in nested SpV structures.

SpV coding is not mandatory for all transitions in a network. Leave inside the SpV transitions of other coding mechanisms can be easily inserted. For example, the SpV-coded first 10 transitions, followed by linearly or separately coded transitions and on finally SpV-encoded again.

The size of the time gain in processing time is essentially the number of edges, depending on the scope of the additional switching condition. In the border areas is also the time for the additional jumps is required crucial criterion for the application of this co dation type.

The network topology must also be taken into account. Strongly meshed networks lead to increased Administrative effort of the transition flags. In exceptional cases, the number of brands on the net can be like this large that there are too many transition conditions to be checked.

Automatic code generation is possible.
[see Fig. 1.4 Flow diagram for jump distributor coding of transitions]

Table 1.7

Coding jump distributor

Table 1.8

Coding the transition for the jump distributor (only the jump distributor is subject to regular, cyclical processing. The processing of the transition code is completely under his control).

1.4.4.1.6 Single-brand jump distributor ESpV

A special form of SpV can be used for coding special network classes or certain networks topologies be useful.

Networks, which are referred to as so-called one-brand networks, have, as the name suggests suggests about only one brand in the entire network.

If the transition whose predecessor location the brand does not have, no other can switch transition in this network. For coding, this means that if one is not switched Transition the rest of the code also doesn't need to be edited. There is no brand transport. It there is no new marking that enables switching.

This method can also be applied to subnetworks or power supply units if there is only one brand within the subject. As an example, an IEC 61131 SFC network is to underpin the discussion. It has a chain (10 steps) followed by a simultaneous branching (40 steps in total). The chain (10 steps) is a typical representative for a one-mark area, so it can be ESpV-coded (the term mark in means that there is only one transition that could switch.) [See Fig. 1.5 Flowchart for jump distributor coding in Single-brand area of transitions]). Chains are interpreted as independent ESpV. Here the jump does not take place at the end of the network but at the beginning of the simultaneous branching. The coding of the simultaneous branching, also consisting of two chains, also uses a jump distributor.

A special coding variant supports the availability of only one mar specified by definition ke in the entire network. In addition, the code is in only one POU. Here you can switch every time you do not switch a return command (leaving the POU) can be used. The use of the return command within the coding ends the POU execution by registering the non-activation of the Transition. However, this method is unsuitable for SFC according to IEC 61131. Since this is the norm given controlled termination of the POU by the system (action processing). Further is the return variant is only of limited suitability considering the aspect of an output assignment. The lower use of computing time depends to a large extent on the marking.

If the brand is at the beginning of the chain or network, the savings are greater than at the end. This is because the jump distributor is always up to the transition, the previous step of which is via the Brand has to be processed.  

Table 1.9

Coding jump distributor for single-brand area

Table 1.10

Coding of the transition for the jump distributor in the one-man area (only the jump distributor is subject to regular, cyclical processing. The processing of the transition code is completely under his control).

1.4.4.1.7 Fine optimization of signal duration

A further reduction in computing time can be achieved taking dynamic pro into account characteristics. This can not be done fully automatically by a compiler because it the dynamic relationships are largely unknown. This smart strategy justifies insists that there is always a signal that the last one is to meet the switching condition contributes. It is often the same signal. Each edge and possibly also the addition is used as a signal condition (e.g. comparison) that belongs to a switching condition.

For example, there is a transition with a previous location (engine turns) and an input (Limit switch reached). Here it is usually the input that ultimately triggers the switching. The programmer must be based on his experience or empirically which signal is suitable voices. Basically there is also the possibility of measurement or logging by the PLC.

For the ECC (Execution Control Chart) of IEC 61499, which is a state machine (Petri net)  is the first to query the event signal of a transition. Because it only occurs for a short time and the last signal is that the switching condition for switching is still missing.

This is applied to the separate, jump distributor and single-label jump distributor coding Signal (maximum should not be more than 2 signals), which ultimately triggers the switching, as the first loading condition written. At least two variants are also conceivable here. A) The rest of the Be The condition from which the signal was extracted may remain as an independent subcondition with Pro there is a branching of a gram, or b) the rest becomes a new one with a different subcondition connected. So there is a partial or total reorganization of those previously regarded as a unit Condition groups (precants, signal precursors, additional condition) instead. These disintegrate in the Analysis of the signal duration to create new groups afterwards. Freedom of choice stands both in the composition and in the number of new groups. At the diving center The signal replaces the flag and the flag can be omitted entirely. That further reduces the time required to implement switching, since flag management is no longer required. Difficult ger is the application of ored edges. The simplest is the entire OR operation as to consider a signal.

There are two last signals that have approximately the same time behavior in the evaluation or If there are fluctuations in time in this regard, occasionally a comparison of the computing time helps contributes to the determination of the result (e.g. computing time for Boolean input and the comparison two integers).

New

In fine tuning, the signals are reorganized to subconditions. The last condition often contains the most complex conditions (e.g. comparators) and / or signals which are actually always met in terms of the switching condition. The number of conditions is arbitrary.
[see Fig. 1.6 Fine-optimized splitting coding]

Table 1.11

Coding of the finely optimized jump distributor

Table 1.12

Coding the transition of the finely optimized jump distributor (only the jump distributor is subject to regular, cyclical processing. The processing of the transition code is completely under his control).

1.4.4.2 Strategies for network optimization

In addition to optimizing the transition coding, an entire network can also be optimized codie ren. The SpV has already been mentioned. Of course, the strategies of transition coding can be additional Lich applied.

The basis for the strategies for network optimization is the knowledge that only network components need to be processed in which there is also a brand, because the brand is the basic requirement for switching. The first and simplest consequence of this is that dead networks or subnetworks are not processed. Some of this can be generated automatically. A typical example is error monitoring of a place (maximum occupancy time exceeded). This only has to be marked Be edited.

The previous discussion brought up a disadvantage of the SpV concept. It is the property Different processing times of the network solely due to the position dependency of a Transiti on (beginning, middle, end) within the SpV code and the marking.

Jumps with dynamic jump targets show an improvement. Unfortunately, these can be found in the IEC 61131 not again, so the following strategies have to be used.

1.4.4.2.1 Chain flag

An unbranched chain is only processed if there is at least one mark in the chain. Efficient localization of existing brands within a chain uses special transit NEN, the chain entry and exit.

The entry transition creates a brand in this chain by switching and starts at the same time Chain flag. If several brands can occur, a counter is used as a flag.

Chain processing is only to be carried out if the chain flag is set or if the chain flag is greater than zero. If a brand leaves the chain, the exit transition resets or decrements the chain flag Counter.

Ultimately, the entirety of all chain flags that run a control network manage, also understand again as an administrative network that is closely related to the control network is coupled.

Software tools are basically able to take the chain flag fully automatically into account management of preset parameters. Another performance gain is through manual Interventions achievable that take into account the dynamic properties. Special attention the choice of entry and exit transitions and the chain length (see section 1.4.4.2.2) must be considered men. Here statistical methods at runtime can determine the probability with regard to duration and Frequency of individual brands help, unless this is determined by process knowledge from the developer pose is. Suitable entry transitions are those whose switching conditions are correspondingly rare is satisfied. Transitions whose switching condition is a date, a clock are an example time, a large delay time or a rather rare process signal.

Or it is the case of an engine stop that is particularly time-critical. The transition from the running motor "state to the" motor stopped "state is modeled in a long unbranched chain. The chain is divided into 3 areas. The transitions before and after the time-critical transition are controlled by flags, while the time-critical transition is always processed, to always be able to switch in the shortest possible time.
[see Fig. 1.7 Flowchart for chain flag coding of networks or subnetworks]

1.4.4.2.2 Segmentation

The means of further segmentation extends the chain flag to a structured chain flag mecha and is suitable for very long chains. For this purpose, long chains are divided into areas the segments. Each segment has its own segment flag. The principle of segment ver administration is the same as that of the chain flag. There are separate entry and exit transitions for each segment. On Extreme segmentation leads to jump distributor coding of the transitions. That is also automatic and manual management, as already described in section 1.4.4.2.1, possible.

Possibly. there is a combination of chain flag and segmentation, although further levels of segmentation are quite permissible. This creates a structure. The chain flag is on the top level, including the first level of the segments. Another segmentation means that a segment controls the segments of its lower level. It then acts like the chain flag that controls the next segment level. The more control distances (segment levels) to be covered, the rarer these network elements should have to be processed or the likelihood of processing decreases. The top level either consists only of management code or additional functional code in the sense of the application.
[see Fig. 1.8 Flowchart for segmented coding of networks or subnetworks]

Principle of the chain flag with further segmentation

A step chain, as shown in black in Fig. 1, only needs to be edited if it also has at least one active step. That is, if processing is omitted because there is no active step, the processing time of the entire chain can be saved. The potential for increasing performance depends on the length of the chain. The longer an unbranched chain is, the greater the increase in performance if there is no active state in it. However, software tools often depict process-oriented languages as if they were a link-oriented model and thus waste part of the effort to determine that no change in status can occur, which was clear from the start.

If there is an active state within a sequencer, the question arises whether the chain is over the entire length to be machined. If the chain can be divided into sub-segments, which in turn only then to be processed if there are active steps within a segment.

When such chain optimization is worthwhile depends, as already mentioned, on the length such a chain, which is the sum of the times of the required commands and of the sum of the the required times of the commands required for coordination.

Optimized chain processing

It is obvious that an optimization of a process model should also be implemented with the means of the model. This means that functions of the compiler that have already been implemented can be used, or manual implementation may also be possible and, above all, conformity to standards can be achieved. Fig. 1 shows how the behavior of chain optimization (marked in red with Petri nets) can be designed with simple means. As soon as the first step of a chain or segment is activated by the transition, one or more chain flags are also set. The flag is reset as soon as the last step of the chain or segment is deactivated.

Here a flag (LeerFlag) is used, which indicates whether the steps of the entire chain are deactivated are fourth and in each case a flag which indicates whether a segment (SgFlag1.. .n) has an active Zu booth. The empty flag can be omitted if necessary, it serves to ensure that only one query in the In the case of a deactivated chain, instead of 3 (SgFlag1. .N) must be done. In this case, almost the ge saved the entire processing time of the chain. The processing time is reduced to almost a third in the presence of an active step within the chain, assuming that all segments take the same processing time.

An extension of this principle leads to an optimization network, the execution management of the actual control network.

This simple procedure can even be realized with the resources that STL provides.

fine tune

An additional performance improvement has to be achieved by using dynamic effects. Each place has specific, process-dependent retention times of the brands. A segmentation whose segments reflect the division of the zones according to the length of stay brings additional benefits. There are areas where brands prefer to stay (longest) and areas with a lower probability of staying. The use of dynamic properties cannot be achieved automatically. The segmentation can thus take place automatically (specified segment size) and manually (user specification for individual segments).
[see Fig. 1.9 section of an undisplayed AS chain whose processing is coordinated by chain flags]

1.4.4.2.3 Single brand dispatcher

If there is only one label in a (sub) network, a CASE instruction can also be used. Each transition then represents a CASE case. It follows that one of all transitions Only one CASE instruction may switch. When switching a transition, it carries its after successor transition into the CASE selector. This variant is suitable for target systems that do not have STL or a similar language. The disadvantage here is that only one transition per processing can switch, unless another loop is placed around the CASE statement. she can Have advantages over the IF statements of the transitions.

1.4.4.2.4 Dispatcher

The dispatcher is very complex. It is particularly suitable for networks with a number of Transitions that could switch due to the network marking are much smaller than those that do not ready to switch. The number of transitions that have the same previous location must be possible be as small as possible (small degree of conflict).

The basic principle is quite simple. There is a list (e.g. array) of the transitions due to the Could switch network marker. Transitions that switch delete themselves from this list and carry all transitions in the list that have one of their successor places as the previous place. Own If several transitions have the same successor position, it is advisable to add these with flags manage so that the corresponding transitions do not appear too early in the list of switchable transis tion because the list management is quite computationally intensive. The list can be made from jump destinations consist of or from pointers.

It can be a disadvantage here that when the best results are achieved, not all space conditions are achieved are stored in Boolean variables. If there is no performance, this is also possible. There forth z. T. from the list of switchable transitions can be inferred about space conditions, which may made the debug mode more complex. In general, all seats could be charged at the computing time Boolean variables. The dispatcher is particularly suitable for implementation directly in the PLC runtime, but can also be implemented in the IEC code.

1.4.4.2.5 Dynamic jump distributor (not for IEC 61131 systems)

As an alternative, the dynamic jump distributor (DSpV) can replace the simple jump distributor or the dispatcher or supplement it in part. If you replace the entire jump distributor with a variable and a jump command with a dynamic jump target, each transition, in its shaft action, instead of the administration of the transition flags, must insert the subsequent transition into the variable. A segregation can be omitted. The management of parallel switchable transitions must not take place in this way without further measures. It is only suitable for unbranched chains with a maximum of one brand. The use of dynamic jump distributors for parallel switchable transitions is more complex. Either lists or loops have to be managed or a jump distributor must be available for every possible parallel connection. With increasing meshing, the complexity increases significantly. Even if the occurrence of restrictions is recognizable, it is worth taking a closer and deeper look as soon as dynamic jump targets can be found in the IEC specification. Some IEC systems already use dynamic jump targets for the effective transformation of CASE instructions in STL, but hide this property from the user.
[see Fig. 1.10 dynamic jump distributor]

Table 1.13

Possible coding of the dynamic jump distributor

Table 1.14

Coding the transition of the dynamic jump distributor

1.4.5 SFC optimization

Due to the prescribed complex processes (action evaluation, network-wide spread a step state (step times) that take place in the background during SFC processing, As far as the reaction rate is concerned, the impression of a "lame duck in comparison to the other languages. By means of optimization, SFC can also become a "road runner" and in many cases represent the solution with the lowest reaction speed. SFC will continue to grow in importance.

Two possible approaches are available to improve the performance of an SFC. Ideally, an SFC system already automatically supports optimization. In the other case remains the user only the optimized manual design of the magnifying glasses (transition, action). However, that is sole profit that can be achieved in this way is always significantly worse than with the automatic or the mix of automatic and manual processes. Both approaches are briefly discussed below animals.

1.4.5.1 SFC systems Transitions

The splitting, the jump distributor and the are of importance for the automatic code generation Single-brand considerations, as well as the chain flag, segmentation and dispatcher. If one The DSpV can also support internal system support for dynamic jump targets come. Semi-automatic fine tuning can also be available.

Determination of the execution of the action

Particular care should be taken when designing campaigns and calling them up. This one As is well known, according to IEC 61131 always have to be processed at least twice, for some reasons took apart. Ultimately, this means that an action is often twice as many Processing is experienced like a transition condition, provided processing takes place. In principle, the optimization mechanisms can be used to determine the execution of transitions. Splitting, fine-tuning over the signal duration and possibly the Dispatchers are particularly useful.

1.4.5.2 Magnifying glass design by the user

Users have, albeit limited, influence on the performance, if appropriate Magnifiers (e.g. transition condition, instructions for actions) are subject to an optimized coding Restrictions are to be found with regard to the standardized properties that cannot be influenced.  In general, these are the strategies for network optimization presented in section 1.4.4.2 inaccessible.

Transition and action magnifying glass

If possible, transition conditions should be in STL, using splitting or fine optimization method or both. This allows the user to directly influence the Take execution time, even if his system does not otherwise offer code optimization. The one The saving effect is strongly dependent on the code implementation of the system. If the transition condition always processed regardless of the previous step, the savings are greatest. Does that happen Processing, on the other hand, only when the step is active, the system already supports optimization form. The performance is further increased.

The frequency with which an action is carried out (see section 1.4.5.1) when it is active may U. contribute significantly to the cycle time.

An action should therefore always be limited to the essential and if possible in STL and if necessary be coordinated with jumps. In doing so, avoid avoiding difficult to read spa focus on ghetticode. There are also general optimization measures of section 1.3 in question.

1.4.6 Petri net code optimization by folding

The general reuse in programming technology is the reuse of software modules, macros or by using templates (objects) and instantiating them. The instantiation is a effective mechanism to generate a compact, transparent code, each instance shows an identical causal behavior pattern with individual status. Regarding the speed There are no significant advantages (especially with IEC 61131 systems). The Only one block body (source) has to be processed for each instance.

Completely or partially identical Petri nets (SFC standard does not allow this) can be folded into a compact form of presentation. The original binary networks (space is represented by a Boolean variable) are folded into bit string networks (8 spaces are represented by a byte variable). This means that up to 8, 16, 32 or 64 binary networks can be processed by a source that only differs in terms of data types (byte, word, double word, long word). The code is also very compact and can be instanced as a whole if required and is characterized by high performance.
[see Fig. 1.11 folded net]

1.5 final remark

In particular, care was taken to ensure that an implementation using the IEC instruction set (before preferably STL) is possible. So there is compatibility, an implementation is both manual as well as automatically possible and last but not least, old projects can be easily adapted (mostly only recompile), provided there is automatic optimization.

As shown, the optimization options are versatile and depend on many parameters. In In many cases, however, an optimized code can be generated automatically. The user stays that way saves a lot of calculations and estimates. The need for fine tuning is subject consideration of each individual case and must be carried out manually. Let the strategies presented Petri nets, SFC, possibly IEC 61499, Grafcet as well as machines and process-oriented models apply. Due to the prescribed behavior of SFC networks (calculation of the Action flags (Q and A), spread of the step state over the entire network, time of destination Chen, step times) the achievable reaction time is generally somewhat longer than for Petrinet ze is expected.

Depending on the topology, network class and marking of a network, a reduction to 5% to 60% (Saving 95% -40%) possible. That means a program that linearly encodes 100 ms would be processed optimally in 5 ms or 60 ms. These are excellent results. This arithmetically on the assumption that each program line takes the same processing time (cf. Excel spreadsheet on the enclosed data carrier). The miraculous change from the "lame duck" for the "road runner" Petri Nets allows one of the solution models with the smallest reaction time if not the fastest control software ever.

The resulting reduction in the required computing power increases the responsiveness or can help meet the ever growing demands for increased functionality or can open up new areas of application for Petri nets and SFC. Furthermore, the optimism possibility, as presented here, another serious argument, like the many advantages  also, the Petri nets offer for their use in control technology. Link-oriented Models do not allow such clear optimization options.

2. Glossary Conflict (forward)

A forward conflict arises when using multiple transitions over a leading edge (standard edge) are connected to the same previous place. Switching a transition can thus cancel the willingness of the rest.

Unbranched chain or unbranched transition sequence describes a sequence of Transitions, the numbering of which is complete and complete, but not necessarily continuous stops do not exist within the parallel switching transitions.

A case is a very specific marking state of a network. So there are two marks differ in that one seat already has a different occupancy two under different cases ??

Ready to switch (weak or insecure)

A transition is ready to switch when all the previous locations are occupied by a sufficient number of brands are so that switching is possible. (General: switching does not result in negative closes stands). The strong or safe switching rule requires that the switch is ready for switching Provide successor places with sufficient capacity to accommodate the brands. This behavior is provided here selectively by the special edge.

Extended switching readiness includes z. B. the pre-edges, PLC input or POE inputs (also negated), query (negated) of places and special edges. It is fulfilled when all of its edges are met are.

Conditional switching readiness includes other conditions including special switching conditions called (comparisons, time conditions, etc.).

Switching rule (convention rule) Switching condition Check the switching condition

Checking the standard pre-edges (activation of the transition). Fulfilled: Corresponds to the readiness to switch
Checking other pre-edges (release of the transition by other pre-edges). Fulfilled: Corresponds to the extended switching readiness
Check other conditions (conditional release of the transition through other conditions). Fulfilled: Corresponds to the conditional switching readiness

Switching operation

Switch when:
Switching = switching readiness & extended switching condition & conditional switching readiness then
Edit instruction block of specialized transition (delete, instruction ...)
Execution management (management of variables for optimization)
Clear the previous places (input or entrance places)
Occupying the successor places (output or exit places)

Switching ratio (SV) of a transition indicates the ratio of the frequency of switching to skin ability of not switching. The sum of non-switching and switching results in the number of ge Complete processing of the transition (or the network) or the source that represents the network. A transition that never switches (is usually nonsensical) has a switching ratio of 0. However, it must not be death, the switching ratio is considered a certain period of time.

A transition that switches just as often as not has a switching ratio of 1. A transition that switches less than non-switching has a switching ratio of 0.5.
SV _T = number of switching / number of non-switching basis: transition processing
SV _N = number of switching / number of non-switching basis: network processing

Number of conflicts Number of all conflicts in a network  Degree of conflict

Identifies the number of transitions that conflict with the same place.

Degree of causality of a transition indicates how many direct predecessor transitions have to switch, so that the switch is ready. This reduces OR-linked standard precursors the degree of causality. Transitions that have the same exit place, the entry place of the examined transition, count with each.

Rarely switching transitions or 01229 00070 552 001000280000000200012000285910111800040 0002010026387 00004 01110 Make processing directly dependent on the location.

logical program length

Number of lines actually processed in a selected program state. Skipped Lines shorten the logical program length, while each loop run an extension mean.

Benchmarks

The term originally refers to the indentations on the workbench of the craftsman kers for length measurement. Applied to technology, the benchmark is a specific task position, which is imposed on computer systems for power measurement in order to ver the measurement results same

3. Literature

Ed. Borland GmbH, programmer's manual Turbo Pascal for Windows Munich 1991
Microsoft Press Germany, Microsoft Visual Basic 6.0 Programmer's Guide Unterschleissheim 1998

4. Check

Can actions also be managed using a dispatcher? If so, which (N, D,...) And what brings it.

Simultaneous chains Under chain flag, each chain as one or more segments.

Claims (5)

1.Procedure for execution time optimization for the implementation of state- or process-oriented models in real solutions (abbreviated Ao), in particular for software-based solutions (technical, business management, organizational or other solutions), characterized in that a causal chain optimization (Kurz Ko), and a Element optimization (Eo for short) for a real model implementation (model is realized, for example, by mapping in a programming language using all suitable properties of the target language) is applied individually or jointly to the implementation of the model or to a part of the model, thereby shortening the processing time (shortened computing time or execution time) of the model implementation or part of the implementation occurs. 2. Process of causal chain optimization according to claim 1, characterized in that a causal chain, part of a long chain or a group of causal chains can only be processed to a limited extent tet (element management) and thus depending on whether the condition (or conditions) is met or does not take less processing time (computing time), the condition (s) in the essential on the evaluation of the current state of the model (marking, other data), its causal chains or its causal chain groups and the use of suitable strategies based and only in the case of at least one active condition (number of marks <= edge weight) half of the causal chain, part of a causal chain or a group of causal chains processing enabled. 3. Elements (functional model elements) of the state- or process-oriented models consist of a condition or conditions (characterizes the criterion where, for example, a To status change occurs) and from a condition-dependent part (realizes, for example, the Transition between states of this model), this is the basis for the method of element optimization according to claim 1, characterized in that the implementation of the model elements, especially for realizable solutions, in the PLC program Mier languages (or similar mechanisms) are mapped using appropriate Strategies in one or more condition parts of a model element adding Branching points (for example a program branch using jumps), on the basis of which the Condition-dependent part (or parts) of a model element only processed if the condition is met is, this therefore does not take any processing time (computing time) if one of the requirements is not met condition parts, the processing of the model element is completed and thus follow-up tasks can ben (e.g. editing the next model element). 4. method of element management according to claim 2, characterized in that a mechanism that exists at runtime and is suitable for changing depending on the model stand, model elements themselves and / or other model elements for processing deregister and / or deregister and / or deregister and / or deregister from other model elements be, whereby this mechanism can possibly occur several times, alternatively by means of a Distribution (jump distributor) the processing of the individual network elements must be coordinated, whereby Mo dellelemente includes all elements involved in the model. 5. method of strategies according to claim 2 and 3, characterized in that Different properties of the (sub) models, the process depicted in the model and the Target platform also require different procedures, these strategies are based on the platform specific processing time of the required commands, the language specific properties of the Target platform, the frequency of occurrence of state transitions in the model or in relation to a Model element, total number of transitions, the number of concurrent state transitions, the Number of simultaneously active states, the likelihood of brands staying in the network (main and side walks of the brands, critical path), the computing time required for one or kei NEN state change, the restriction to only one active state or the occurrence of this Property in a (sub) network (one-brand networks or areas), the degree of meshing, the length of causal chains, the decomposition of chains into partial chains, the presence of active ones  States in (partial) chains or (partial) networks, the completion of processing subsequent (Partial) chains or (partial) networks, if obviously no change of state can take place anymore Position (sequence of processing) of the element in the network (top, bottom) or in the chain, the Frequency of processing an element (element, chain, network), the scope of a model mentes, the decomposition of a condition into partial conditions, the time interval between fulfillment development of a partial condition and the fulfillment of the entire condition, the length of stay of brands in (Sub) networks, the management of the elements to be processed using jump distributors or lists, the Network properties dead and alive, convolution or parallelization (identical binary networks coded with bit sequences (such as byte, word, etc.) of the definition of the corresponding network properties (one-mar kennetze), the analysis of process properties at design and at runtime, for optimization strategy to determine the appropriate application of the strategies on colored networks, predicate network ze, networks with space capacity <1, other networks.