Zélus

Hybrid systems modeling languages are widely used in the development of embedded systems. Two representatives are Simulink/Stateflow1 that combine Ordinary Differential Equations (ODEs), data-flow and difference equations, hierarchical automata a la StateCharts [14] together with imperative features; and the Modelica language [1]2 based on DAEs with features for modeling discrete components. Ptolemy II3 is another example in which several models of computation are combined [15].The formal verification of hybrid systems has been extensively studied [9]. Yet, we share the viewpoint of Lee and Zheng that hybrid modeling languages are best viewed as programming languages that happen to have a hybrid systems semantics [16, 17]. This raises important questions related to their design, semantics and implementation, to get efficient and reliable simulations as well as provably equivalent embedded target code. While sequential code generation in hybrid modeling tools is routinely used for efficient simulation, it is little used or not used at all to produce target embedded code in critical applications that are submitted to strong safety requirements. This results in a break in the development chain: parts of applications must be rewritten into sequential code and all properties verified on the source model cannot be trusted and have to be reverified on the target code.Sequential code generation from a synchronous language like Lustre [12] has been studied in detail [13]. It can be formalized as a series of source-to-source transformations that eliminate high level constructs like hierarchical automata [11] and the generation of a generic intermediate representation for transition functions, turned itself into C code [6]. This approach, initiated in Lucid Synchrone [18], is implemented in the Scade Suite KCG code generator of Scade 64, used for developing various critical applications.Yet, synchronous languages only manipulate discrete-time signals. Their expressiveness is limited to insure important safety properties like determinacy, execution in bounded time and space, and simple, traceable code generation. Their cyclic execution requires minimal run-time support and does not suffer the complications that accompany numerical solvers of ordinary differential equations. Conversely, a hybrid modeling language allows discrete and continuous time behaviors to interact. But this interaction is not constrained enough, nor specified with adequate precision in tools like Simulink/Stateflow and this occasion semantics pitfalls and bugs [10, 5, 2]. A precise description of all the compilation steps, that is, the actual implemented semantics, is mandatory in safety critical development processes where target code must be trustworthy. Our goal, in short, is to increase the expressiveness of synchronous languages without sacrificing any confidence in their compilers.In previous works, we introduced a novel approach for the design and implementation of a hybrid modeling language that reuses synchronous language principles and an existing compiler infrastructure. We introduced an ideal synchronous semantics based on non standard analysis [5] for a Lustre-like language with ODEs [4], and then extended the kernel language with hierarchical automata [3] and a modular causality analysis [2]. These results form the foundation of Zelus [8]5 and were validated inside the industrial Scade Suite KCG code generator (Release 6.4, 2014) developed at Esterel-Technologies/ANSYS [7].In this talk, I will summarize the ongoing work on Zelus and the way it has been applied to the Scade Suite KCG code generator. In the later, it was possible to reuse the existing infrastructure entirely with little modifications: static typing, the causality and initialization analysis, intermediate languages and the various compiler optimizations. The proposed language extension is conservative in that regular synchronous functions are compiled as before --- the same synchronous code is used both for simulation and for execution on target platforms. It also shows the versatility of the KCG infrastructure based on a successive rewriting. The precise definition of all compilation steps, built on the proven compiler infrastructure of a synchronous language avoids the rewriting of control software and may also increase the confidence in simulation results.This work results from a collaboration with Albert Benveniste, Benoit Caillaud (INRIA, Rennes), Timothy Bourke (INRIA, Paris-Rocquencourt), Jean-Louis Colaco, Bruno Pagano and Cedric Pasteur (Esterel-Technologies/ANSYS).

Explicit hybrid systems modelers like Simulink/Stateflow allow for programming both discrete- and continuous-time behaviors with complex interactions between them. A key issue in their compilation is the static detection of algebraic or causality loops. Such loops can cause simulations to deadlock and prevent the generation of statically scheduled code.This paper addresses this issue for a hybrid modeling language that combines synchronous data-flow equations with Ordinary Differential Equations (ODEs). We introduce the operator last(x) for the left-limit of a signal x. This operator is used to break causality loops and permits a uniform treatment of discrete and continuous state variables. The semantics relies on non-standard analysis, defining an execution as a sequence of infinitesimally small steps. A signal is deemed causally correct when it can be computed sequentially and only changes infinitesimally outside of announced discrete events like zero-crossings. The causality analysis takes the form of a type system that expresses dependences between signals. In well-typed programs, signals are provably continuous during integration provided that imported external functions are also continuous.The effectiveness of this system is illustrated with several examples written in Zelus, a Lustre-like synchronous language extended with hierarchical automata and ODEs.

Hybrid systems modelers like Simulink come with a rich collection of discrete-time and continuous-time blocks. Most blocks are not defined in terms of more elementary ones—and some cannot be—but are instead written in imperative code and explained informally in a reference manual. This raises the question of defining a minimal set of orthogonal programming constructs such that most blocks can be programmed directly and thereby given a specification that is mathematically precise, and whose compiled version performs comparably to handwritten code. In this paper, we show that a fairly large set of blocks of a standard library like the one provided by Simulink can be programmed in a precise, purely functional language using stream equations, hierarchical automata, Ordinary Differential Equations (ODEs), and deterministic synchronous parallel composition. Some blocks cannot be expressed in our setting as they mix discrete-time and continuous-time signals in unprincipled ways that are statically forbidden by the type checker. The experiment is conducted in Zélus, a synchronous language that conservatively extends L ustre with ODEs to program systems that mix discrete-time and continuous-time signals.

Parallelization of an existing sequential application to achieve a good speed-up on a data-parallel infrastructure is quite difficult and time consuming effort. One of the important steps towards this is to assess whether the existing application in its current form can be parallelized to get the desired speedup. In this paper, we propose a method of analyzing an existing sequential source code that contains data-parallel loops, and give a reasonably accurate prediction of the extent of speedup possible from this algorithm. The proposed method performs static and dynamic analysis of the sequential source code to determine the time required by various portions of the code, including the data-parallel portions. Subsequently, it uses a set of novel invariants to calculate various bottlenecks that exists if the program is to be transferred to a GPGPU platform and predicts the extent of parallelization necessary by the GPU in order to achieve the desired end-to-end speedup. Our approach does not require creation of GPU code skeletons of the data parallel portions in the sequential code, thereby reducing the performance prediction effort. We observed a reasonably accurate speedup prediction when we tested our approach on multiple well-known Rodinia benchmark applications, a popular matrix multiplication program and a fast Walsh transform program.

Biopathways are often modeled as systems of ordinary differential equations (ODEs). Such systems will usually have many unknown parameters and hence will be difficult to calibrate. Since the data available for calibration will have limited precision, an approximate representation of the ODEs dynamics should suffice. One must, however, be able to efficiently construct such approximations for large models and perform model calibration and subsequent analysis. We present a graphical processing unit (GPU) based scheme by which a system of ODEs is approximated as a dynamic Bayesian network (DBN). We then construct a model checking procedure for DBNs based on a simple probabilistic linear time temporal logic. The GPU implementation considerably extends the reach of our previous PC-cluster-based implementation (Liu et al., 2011b). Further, the key components of our algorithm can serve as the GPU kernel for other Monte Carlo simulations-based analysis of biopathway dynamics. Similarly, our model checking framework is a generic one and can be applied in other systems biology settings. We have tested our methods on three ODE models of bio-pathways: the epidermal growth factor-nerve growth factor pathway, the segmentation clock network and the MLC-phosphorylation pathway models. The GPU implementation shows significant gains in performance and scalability whereas the model checking framework turns out to be convenient and efficient for specifying and verifying interesting pathways properties. The source code is freely available at http://www.comp.nus.edu.sg/~rpsysbio/pada-gpu/

Summary: MATLAB is popular in biological research for creating and simulating models that use ordinary differential equations (ODEs). However, sharing or using these models outside of MATLAB is often problematic. A community standard such as Systems Biology Markup Language (SBML) can serve as a neutral exchange format, but translating models from MATLAB to SBML can be challenging—especially for legacy models not written with translation in mind. We developed MOCCASIN (Model ODE Converter for Creating Automated SBML INteroperability) to help. MOCCASIN can convert ODE-based MATLAB models of biochemical reaction networks into the SBML format.Availability and implementation: MOCCASIN is available under the terms of the LGPL 2.1 license (http://www.gnu.org/licenses/lgpl-2.1.html). Source code, binaries and test cases can be freely obtained from https://github.com/sbmlteam/moccasin.Contact: mhucka@caltech.eduSupplementary information: More information is available at https://github.com/sbmlteam/moccasin.

Interval-based Solving of Hybrid Constraint Systems

Software refactoring is a very well-studied subject, but with the huge gap between omnipresent multicore processors and the vast majority of software that has not been developed with multicore in mind, it gains new and important significance: At what locations should the sequential code be refactored? How should this be done for a given location? Is the code still correct? And finally: Does it execute faster? In this paper we present a refactoring concept to exploit parallelizable regions in legacy software. Our concept relies on the presence of recurring patterns and identifies potential regions, transforms them to parallel versions, tests them for correctness and tunes their parallel performance. We show early implementation results.

Systems with both continuous and discrete behaviors can be modeled using a mixed-signal style or a hybrid systems style. This article presents a component-based modeling and simulation framework that supports both modeling styles. The component framework, based on an actor metamodel, takes a hierarchical approach to manage heterogeneity in modeling complex systems. We describe how ordinary differential equations, discrete event systems, and finite-state machines can be built under this metamodel. A mixed-signal system is a hierarchical composition of continuous-time and discrete event models, and a hybrid system is a hierarchical composition of continuous-time and finite-state-machine models. Hierarchical composition and information hiding help build clean models and efficient execution engines. Simulation technologies, in particular, the interaction between a continuous-time ODE solving engine and various discrete simulation engines are discussed. A signal type system is introduced to schedule hybrid components inside a continuous-time environment. Breakpoints are used to control the numerical integration step sizes so that discrete events are handled properly. A "refiring" mechanism and a "rollback" mechanism are designed to manage continuous components inside a discrete event environment. The technologies are implemented in the Ptolemy II software environment. Examples are given to show the applications of this framework in mixed-signal and hybrid systems.

Dear SCPE Reader, We present a selection of papers which are extensions of papers presented at the 7-th International Symposium on Parallel and Distributed Computing, 1–5 July 2008, in Krakow, Poland. The motivation for publishing the selection in the SCPE Journal was, on the one hand, to present the flavour of the research reported at the conference and on the other hand to present some of the most relevant topics currently focused on the research on parallel and distributed computing in general. The selection contains only 6 papers out of about 60 presented at the conference, and thus, is far from covering all relevant topics represented at the ISPDC 2008. This is because not all of the invited authors were patient enough to accept a fairly long paper publishing process. Nevertheless, we hope that the presented papers will bring you closer to the research covered by the ISPDC conferences and will encourage you to participate in future ISPDC editions. The first paper ``The Impact of Workload Variability on Load Balancing Algorithms'' is by Marta Beltran and Antonio Guzman from King Juan Carlos University in Spain. It concerns an important topic of load balancing in cluster systems, namely adaptativity of the load balancing algorithms to changes of the workload in the system. Adequate accounting for additional load in the hosting system is of great relevance for correct optimization effects. The paper presents a thorough formal analysis of the workload variability metrics and their influence on the quality of load balancing algorithms. Four basic activities appearing in load balancing algorithms are identified, and based on them some algorithmic solutions are proposed to correctly deal with workload variability in system load balancing. The problem of dynamic load balancing algorithms robustness has been discussed. Two different robustness metrics sensitive to the applied type of opimization: local task-oriented or a global one enable selecting task remote execution or migration as load balancing operations. The proposed approach is illustrated with experiments. The second paper ``Model-Driven Engineering and Formal Validation of High-Performance Embedded Systems'' is by Abdoulaye Gamatie, Eric Rutten, Huafeng Yu, Pierre Boulet, Jean-Luc Dekeyser, from University of Lille and INRIA in France. The paper is concerned with a very advanced methodology of designing correct parallel embedded systems for intensive data-parallel computing. In their previous research, the authors of the paper designed the GASPARD embedded system design framework. It is based on the hardware/software co-design approach through model-driven engineering. The framework is based on an UML-like model specification language in which hardware and software elements are modelled using a component approach with special mechanisms for repetitive structures. This paper tries to combine the modelling framework of GASPARD with the mechanisms of synchronous languages to achieve design verifiability provided for such languages. The paper shows how GASPARD models can be translated into synchronous models based on data flow equations in order to formally check their correctness. The proposed approach is illustrated with an example of a video processing system. The third paper ``Relations Between Several Parallel Computational Models'' is by Stephan Bruda and Yuanqiao Zhang from Bishop’s University in Canada. The paper is concerned with theoretical aspects of shared memory systems described by the parallel random access machine PRAM model and aims in studying performance properties of different types of PRAM systems. The attention is focussed on analysing the computational power of two more sophisticated PRAM models (Combining CRCW and Broadcast Selective Reduction), which include data reduction in case of concurrent writes. The paper shows that these two models have equivalent computational power, which is a new result comparing the existing literature. The performance of both models applied to reconfigurable multiple bus machines was studied as a possible architectural solution for current VLSI processor implementations. It was shown that in such systems under reasonable assumptions concurrent-write does not enhance performance comparing the exclusive-write model. Another result important for the VLSI technology is that the Combining CRCW PRAM model (in which data of concurrent writes are arthmetically or logically combined before write) and the exclusive-write on directed reconfigurable busses perform in equivalent way under strong real-time requirements. The fourth paper ``Experiences with Mesh-Like Computations Using Prediction Binary Trees'' is by Gennaro Cordasco, Biagio Cosenza, Rosario de Chiara, Ugo Erra and Vittorio Scarano from the University ``degli Studi'' of Salerno and the University ``degli Studi della Biasilicata'' of Potenza in Italy. The paper concerns optimization methods for mesh-like computations in clusters of processors. The computations are perfomed assuming a phase-like program execution control using a tiling approach which reduces inter-processor communication. A temporal coherence is also assumed, which means that task sizes provide similar execution times in consecutive phases. Temporary coherent computations are structured in a Prediction Binary Tree, in which leaves represent computing tiles to be mapped to processors. A phase-by-phase semi-static load balancing is introduced to the scheduling algorithm. The scheduling algorithm is equipped with a predictor, which estimates the computation time of next phase tiles based on previous execution times and modifies the tiles to achieve balanced execution in phases. For this, two heuristics are used to leverage on data locality in processors. The proposed approach is illustrated by the example of interactive rendering with Parallel Ray Tracing algorithm. The fifth paper ``The Influence of the IBM pSeries Servers Virtualization Mechanism on Dynamic Resource Allocation in AIX 5L'' is by Maciej Mlynski from ASpartner Limited in Poland. The paper concerns a very up-to-date problem of system virtualization and presents the results of research carried on IBM pSeries servers. IBM is strongly developing the virtualization technique especially on IBM pSeries servers enabling an improved and flexible sharing of system resources between applications. The paper investigates novel facilities for dynamic resource management such as micro-partitioning and partition load manager. They enable dynamic creation of workload logical partitions of system resources and their dynamic mangement. It includes run-time resource re-alocation between logical partitions including setting of sharing specifications as well as run-time adding/removing/setting parameters of resources in the system. It remains an open question how to properly tune parameters of the operating system using the provided virtualization facilities to obtain the best efficiency for a given application program. The paper presents the results of experiments which study the effects of tuning the disk subsystem parameters under the IBM AIX 5L operating system with the use of the provided virtualization facilities on the resulting application execution performance. The results show that even small deterioration in the resource pool status requires an immediate adaptation of the operating system parameters to maintain the required performance. The sixth paper ``HeteroPBLAS: A Set of Parallel Basic Linear Algebra Subprograms Optimized for Heterogeneous Computational Clusters'' is by Ravi Reddy, Alexey Lastovetsky and Pedro Alonso from University College Dublin in Ireland and Polytechnic University of Valencia in Spain. The paper concerns the methodology for parallelization of linear algebra computations for execution in heterogeneous cluster environments. The design of the HeteroPBLAS library (Parallel Basic Linear Algebra Subprograms) for heterogeneous computational clusters is presented. The main contribution of the paper is the automation of the parallelization and optimization of the PBLAS, which is done by means of a special user interface and the underlying set of functions. An important element is here a performance model that is based on program code instrumentation, which determines parameters of the application and the executive heterogeneous platform relevant for execution performance of parallel code. The parameter values specified for or returned by execution of the performance model functions are next used for generation and optimal mapping of the parallel code of the library subroutines. The proposed approach is illustrated by experimental results of execution of optimized HeteroPBLAS programs on homogeneous and heterogeneous computing clusters. Marek Tudruj

Predicting potential side effects of drugs by recommender methods and ensemble learning

In this paper, we leverage a foundational principle of analog electronic circuitry, Kirchhoff's current and voltage laws, to introduce a distinctive class of neural network models termed KirchhoffNet. Essentially, KirchhoffNet is an analog circuit that can function as a neural network, utilizing its initial node voltages as the neural network input and the node voltages at a specific time point as the output. The evolution of node voltages within the specified time is dictated by learnable parameters on the edges connecting nodes. We demonstrate that KirchhoffNet is governed by a set of ordinary differential equations (ODEs), and notably, even in the absence of traditional layers (such as convolution layers), it attains state-of-the-art performances across diverse and complex machine learning tasks. Most importantly, KirchhoffNet can be potentially implemented as a low-power analog integrated circuit, leading to an appealing property --- irrespective of the number of parameters within a KirchhoffNet, its on-chip forward calculation can always be completed within a short time. This characteristic makes KirchhoffNet a promising and fundamental paradigm for implementing large-scale neural networks, opening a new avenue in analog neural networks for AI. Our source code and model checkpoints are publicly available: https://github.com/zhengqigao/kirchhoffnet.

Finding suitable models of dynamic biochemical systems is an important task in systems biology approaches to the biosciences. On the one hand, a correct model helps to understand the underlying mechanisms and on the other hand, one can use the model to predict the behavior of a biological system under various circumstances. Typically, before the correct model of a biochemical system is found, different hypothetical models might be reasonable and consistent with previous knowledge and available data. The main goal now is to find the best suited model out of different hypotheses. The process of falsifying inappropriate candidate models is called model discrimination. We have developed a new computational tool to compute optimal experiments for biochemical kinetic systems with underlying ordinary differential equation (ODE) models for the purpose of model discrimination. We were inspired by the demands of biological experimentalists which perform one run measurement where perturbations to the system are possible. We provide a criterion which calculates the number and location of time points of optimal measurements as well as optimal initial conditions and optimal perturbations to the system. The model discrimination algorithm described here is implemented in C++ in the package ModelDiscriminationToolkit. The source code can be downloaded from http://omnibus.unifreiburg.de/~ds500/_software.html.

Amphibious fishes moving from water to land experience continuous changes in environmental forces. How these subtle changes impact behavioural transitions cannot be resolved by comparisons of aquatic and terrestrial locomotion. For example, aquatic and terrestrial locomotion appear distinct in the actinopterygian fish Polypterus senegalus; however, it is unclear how gradual water level changes influence the transition between these locomotor behaviours. We tested the hypothesis in P. senegalus that swimming and walking are part of an incremental continuum of behaviour and muscle activity across the environmental transition from water to land rather than two discrete behaviours, as proposed by previous literature. We exposed P. senegalus to discrete environments from fully aquatic to fully terrestrial while recording body and pectoral fin kinematics and muscle activity. Anterior axial red muscle effort increases as water depth decreases; however, a typical swimming-like anterior-to-posterior wave of axial red muscle activity is always present, even during terrestrial locomotion, indicating gradual motor control changes. Thus, walking appears to be based on swimming-like axial muscle activity whereas kinematic differences between swimming and walking appear to be due to mechanical constraints. A discrete change in left-right pectoral fin coordination from in-phase to out-of-phase at 0.7 body depths relies on adductor muscle activity with a similar duty factor and adductor muscle effort that increases gradually as water depth decreases. Thus, despite distinct changes in kinematic timing, neuromuscular patterning is similar across the water depth continuum. As the observed, gradual increases in axial muscle effort reflect muscle activity changes between aquatic and terrestrial environments observed in other elongate fishes, a modified, swimming-like axial muscle activity pattern for terrestrial locomotion may be common among elongate amphibious fishes.

Hybrid systems are systems that involve continuous and discrete event dynamical behaviors. A impulsive system is a special hybrid system. The continuous dynamics of impulsive systems are usually described by ordinary differential equations and the discrete event dynamics with instantaneously rapid jumps are described by switching laws. Various complex dynamical phenomena that can be modeled by impulsive systems arise in many areas of modern science and technology such as economics, physics, chemistry, biology, information science, radiotherapy, acupuncture, robotics, neural networks, automatic control, artificial intelligence, space technology, and telecommunications, etc. In modern control theory, controllability is one of the most important dynamical properties of considered impulsive systems, therefore, the controllability problem is regarded as one of the fundamental issues of impulsive systems. The basic questions for controllability of impulsive systems as well as for the ordinary systems without impulses and with control function are to obtain useful criteria that allow us to identify whether given dynamic systems are controllable or not. Up to now there have been being many investigation results for controllability of different kinds of impulsive systems with respect to the terminal state constraints of a point type. The purpose of this paper is to study relative controllability with respect to the terminal state constraint of a general type for a class of linear time-varying impulsive systems. In this paper, several types of criteria for relative controllability of such systems are established by a algebraic method, that is, specially speaking, by the matrix rank method. Some corresponding necessary and sufficient conditions for controllability of linear time-invariant impulsive systems are also obtained more compactly. Meanwhile, for given impulsive systems some equivalent relationships between different kinds of controllability are investigated and our criteria for relative controllability are compared with the existing results. A simple example is given to illustrate the utility of our criteria.