17 research outputs found
Envisioning Model-Based Performance Engineering Frameworks.
Abstract Our daily activities depend on complex software systems that must guarantee certain performance. Several approaches have been devised in the last decade to validate software systems against performance requirements. However, software designers still encounter problems in the interpretation of performance analysis results (e.g., mean values, probability distribution functions) and in the definition of design alternatives (e.g., to split a software component in two and redeploy one of them) aimed at fulfilling performance requirements. This paper describes a general model-based performance engineering framework to support designers in dealing with such problems aimed at enhancing the system. The framework relies on a formalization of the knowledge needed in order to characterize performance flaws and provide alternative system design. Such knowledge can be instantiated based on the techniques devised for interpreting performance analysis results and providing feedback to designers. Three techniques are considered in this paper for instantiating the framework and the main challenges to face during such process are pointed out and discussed
Limiting Behavior of Markov Chains with Eager Attractors
We consider discrete infinite-state Markov chains which contain an eager finite attractor. A finite attractor is a finite subset of states that is eventually reached with probability 1 from every other state, and the eagerness condition requires that the probability of avoiding the attractor in n or more steps after leaving it is exponentially bounded in n. Examples of such Markov chains are those induced by probabilistic lossy channel systems and similar systems. We show that the expected residence time (a generalization of the steady state distribution) exists for Markov chains with eager attractors and that it can be effectively approximated to arbitrary precision. Furthermore, arbitrarily close approximations of the limiting average expected reward, with respect to state-based bounded reward functions, are also computable.
Decoupled Fitness Criteria for Reactive Systems
The correctness problem for reactive systems has been thoroughly explored and
is well understood. Meanwhile, the efficiency problem for reactive systems has
not received the same attention. Indeed, one correct system may be less fit
than another correct system and determining this manually is challenging and
often done ad hoc. We (1) propose a novel and general framework which
automatically assigns comparable fitness scores to reactive systems using
interpretable parameters that are decoupled from the system being evaluated,
(2) state the computational problem of evaluating this fitness score and reduce
this problem to a matrix analysis problem, (3) discuss symbolic and numerical
methods for solving this matrix analysis problem, and (4) illustrate our
approach by evaluating the fitness of nine systems across three case studies,
including the Alternating Bit Protocol and Two Phase Commit.Comment: v2 notable changes: - updated discussion of "component separable" -
updated presentation/organization of section 4 - updated
presentation/organization of section 5 - added new case stud
Efficient Emptiness Check for Timed B\"uchi Automata (Extended version)
The B\"uchi non-emptiness problem for timed automata refers to deciding if a
given automaton has an infinite non-Zeno run satisfying the B\"uchi accepting
condition. The standard solution to this problem involves adding an auxiliary
clock to take care of the non-Zenoness. In this paper, it is shown that this
simple transformation may sometimes result in an exponential blowup. A
construction avoiding this blowup is proposed. It is also shown that in many
cases, non-Zenoness can be ascertained without extra construction. An
on-the-fly algorithm for the non-emptiness problem, using non-Zenoness
construction only when required, is proposed. Experiments carried out with a
prototype implementation of the algorithm are reported.Comment: Published in the Special Issue on Computer Aided Verification - CAV
2010; Formal Methods in System Design, 201
Better abstractions for timed automata
We consider the reachability problem for timed automata. A standard solution
to this problem involves computing a search tree whose nodes are abstractions
of zones. These abstractions preserve underlying simulation relations on the
state space of the automaton. For both effectiveness and efficiency reasons,
they are parametrized by the maximal lower and upper bounds (LU-bounds)
occurring in the guards of the automaton. We consider the aLU abstraction
defined by Behrmann et al. Since this abstraction can potentially yield
non-convex sets, it has not been used in implementations. We prove that aLU
abstraction is the biggest abstraction with respect to LU-bounds that is sound
and complete for reachability. We also provide an efficient technique to use
the aLU abstraction to solve the reachability problem.Comment: Extended version of LICS 2012 paper (conference paper till v6). in
Information and Computation, available online 27 July 201
Action Codes
We provide a new perspective on the problem how high-level state machine models with abstract actions can be related to low-level models in which these actions are refined by sequences of concrete actions. We describe the connection between high-level and low-level actions using action codes, a variation of the prefix codes known from coding theory. For each action code ?, we introduce a contraction operator ?_? that turns a low-level model ? into a high-level model, and a refinement operator ?_? that transforms a high-level model ? into a low-level model. We establish a Galois connection ?_?(?) ? ? ? ? ? ?_?(?), where ? is the well-known simulation preorder. For conformance, we typically want to obtain an overapproximation of model ?. To this end, we also introduce a concretization operator ?_?, which behaves like the refinement operator but adds arbitrary behavior at intermediate points, giving us a second Galois connection ?_?(?) ? ? ? ? ? ?_?(?). Action codes may be used to construct adaptors that translate between concrete and abstract actions during learning and testing of Mealy machines. If Mealy machine ? models a black-box system then ?_?(?) describes the behavior that can be observed by a learner/tester that interacts with this system via an adaptor derived from code ?. Whenever ?_?(?) implements (or conforms to) ?, we may conclude that ? implements (or conforms to) ?_? (?).
Almost all results, examples, and counter-examples are formalized in Coq
Symbolic Simulation of Dataflow Synchronous Programs with Timers
International audienceThe synchronous language Lustre and its descendants have long been used to program and model discrete controllers. Recent work shows how to mix discrete and continuous elements in a Lustre-like language called ZĂ©lus. The resulting hybrid programs are deterministic and can be simulated with a numerical solver. In this article, we focus on a subset of hybrid programs where continuous behaviors are expressed using timers, nondeterministic guards, and invariants, as in Timed Safety Automata. We propose a source-to-source compilation pass to generate discrete code that, coupled with standard operations on Difference-Bound Matrices, produces symbolic traces that each represent a set of concrete traces
Platform-independent profiling in a virtual execution environment
Virtual execution environments, such as the Java virtual machine, promote platform-independent software development. However, when it comes to analyzing algorithm complexity and performance bottlenecks, available tools focus on platform-specific metrics, such as the CPU time consumption on a particular system. Other drawbacks of many prevailing profiling tools are high overhead, significant measurement perturbation, as well as reduced portability of profiling tools, which are often implemented in platform-dependent native code. This article presents a novel profiling approach, which is entirely based on program transformation techniques, in order to build a profiling data structure that provides calling-context-sensitive program execution statistics. We explore the use of platform-independent profiling metrics in order to make the instrumentation entirely portable and to generate reproducible profiles. We implemented these ideas within a Java-based profiling tool called JP. A significant novelty is that this tool achieves complete bytecode coverage by statically instrumenting the core runtime libraries and dynamically instrumenting the rest of the code. JP provides a small and flexible API to write customized profiling agents in pure Java, which are periodically activated to process the collected profiling information. Performance measurements point out that, despite the presence of dynamic instrumentation, JP causes significantly less overhead than a prevailing tool for the profiling of Java code