To manage complexity and to shorten design time, systemlevel methods for specification and design are becoming indispensable. System-level methods and tools focus on the creation of executable models that describe a system in the earliest phases of the design process. They allow qualitative (correctness) and quantitative (performance) properties to be analyzed before the system is actually being realized in terms of hardware and software components. The results of such early analysis can be used as input for taking well-founded design decisions.

In this paper we develop a probabilistic real-time calculus for performance evaluation. The calculus applies a simple generative model of probabilities. Next to probabilistic action transitions, probabilistic time transitions are supported. An operational characterization is given in terms of a labelled transition system. The operational rules for the real-time part of the calculus are constructed in such a way, that the transition system can be interpreted as a discrete-time Markov chain. They further yield a constructive approach towards the efficient execution of processes and generation of transition graphs. On top of the operational rules, bisimulation equivalence is defined and proven to be a congruence for all operators. We define three different performance characteristics in terms of reward functions and prove that equivalent processes have an identical performance. Using an ergodic theorem of Markov chains, we further show how these performance figures can be computed in practice. We introduce an experimental software tool and we show how it can be applied to calculate the performance of a nontrivial real-time data communication protocol. 1

Abstract: Integration of increasingly complex systems on a chip augments the need of system-level methods for specification and design. In the earliest phases of the design process important design decisions can be taken on the basis of a fast exploration of the design space. This paper describes an abstract modeling approach towards system-level design-space exploration which is formal and flexible. It uses a uniform system model that contains both functional and architectural information. Disjunct, parameterizable resources represent the real-time behavior of the target architecture. Due to the expressiveness of the modeling language (POOSL), control as well as data oriented behavior can be specified in the functional part of the system model. Well-founded design decisions can be taken as a result of performance estimations that are based on Markov theory. Key words: architecture exploration, design-space exploration, performance modeling,

Before implementing a system with hardware and software components, performance modelling is often used for evaluating design alternatives. The formal modelling language Parallel Object-Oriented Specification Language (POOSL) has proven to be very useful for analysing performance metrics of design alternatives for real-life industrial systems. Based on its mathematically defined semantics, POOSL enables to analytically compute performance metrics by analysing the Markov chain that is implicitly defined by a POOSL model.

To manage complexity and to shorten design time, systemlevel methods for specification and design are becoming more and more important. System-level methods and tools focus on the creation of executable models that describe a system in the earliest phases of the design process. They allow qualitative (correctness) and quantitative (performance) properties to be analyzed before the system is actually being realized in terms of hardware and software components. The results of such early analysis can be used as input for taking structured and well-founded design decisions.

We study system-level design methods for complex real-time hardware/software systems. Systemlevel design methods enable developing an executable model that allows to evaluate the performance of a system before implementing it with hardware and software components. Based on such performance analysis results, designers are able to properly decide upon different alternatives that reaHse the requested functionality.

System level modeling languages support the creation of executable system models in the earliest stages of the design process. Executable specifications allow the properties of a system to be analyzed and verified before this system is actually being realized in terms of hardware and software components. The POOSL language is a system level modelling language for complex real-time hardware/software systems. The language has proven to be very useful to describe real-life systems and to verify their correctness properties. Unfortunately, currently POOSL does not support the possibility to analyze performance properties. This is a major disadvantage because performance characteristics play a key role in the design of many hardware /software systems. This paper aims at extending the POOSL language with the capabilities to express probabilistic behaviour and to analyze performance figures analytically. The paper complements the work presented in [16] where the focus was on empirical performance analysis. To present the key ideas we develop a real-time probabilistic process calculus that is able to express the basic concepts of POOSL. We introduce an experimental software tool supporting the calculus and it is shown how the tool enables the calculation of the performance of a data link protocol. Keywords--- system-level modeling; performance evaluation; formal specification I.

In order to deal with the complexity of hardware / software designs, design methodologies are applied, many of which are based on objectoriented design concepts, for example UML. Using such a methodology one can create executable models of the system to be designed. These models can be used to verify that the system displays the desired behaviour. Automated verification tools allow the designer to express wanted or unwanted behaviour of the system and search for satisfaction or violation of these behaviours. It is the state-space-explosion problem that makes that verification tools are typically applied to small models and that careful modelling is required to keep the number of reachable states small. For this reason, current languages and logics often operate on a low level of abstraction, offering little structuring and abstraction concepts. It is possible to use verification methods in other stages of the design process as well. Properties can be monitored during simulations of a system model. One would like to be able to use these logical properties in the same design framework, using such concepts as structuring and hierarchy, encapsulation, inheritance and so forth. In this paper we will investigate the use of formal models offering these concepts in the context of the design methodology SHE and its formal specification language POOSL. A calculus supporting structural hierarchy and encapsulation will be introduced with suitable equivalences. Furthermore temporal logics will be defined that fit to this calculus and it will be shown that such logics can be used to specify properties of hierarchical systems. Keywords--- formal verification, CCS, temporal logic, distribution, object-oriented methods I.

Today many formalisms exist for specifying complex Markov chains. In contrast, formalisms for specifying rewards, enabling the analysis of long-run average performance properties, have remained quite primitive. Basically, they only support the analysis of relatively simple performance metrics that can be expressed as long-run averages of atomic rewards, i.e. rewards that are deductible directly from the individual states of the initial Markov chain specification. To deal with complex performance metrics that are dependent on the accumulation of atomic rewards over sequences of states, the initial specification has to be extended explicitly to provide the required state information.

A major problem in performance evaluation of real-life industrial systems is the enormous number of states generated by the system's model during the simulation process. An example is in a Parallel Object-Oriented Specification Language (POOSL) model, which can be interpreted as a discrete-time Markov chain enabling the evaluation of long-run average performance metrics. In general this Markov chains is huge, making performance simulation expensive since all performance estimations must be updated in each state.