Runtime Properties Research Articles

Adaptive Reactive Synthesis for LTL and LTLf Modulo Theories

Reactive synthesis is the process of generate correct con- trollers from temporal logic specifications. Typically, synthesis is restricted to Boolean specifications in LTL. Recently, a Boolean abstraction technique allows to translate LTLT specifications that contain literals in theories into equi-realizable LTL specifications, but no full synthesis procedure exists yet. In synthesis modulo theories, the system receives valuations of environment variables (from a first-order theory T ) and outputs valuations of system variables from T . In this paper, we address how to syntheize a full controller using a combination of the static Boolean controller obtained from the Booleanized LTL specification together with on-the-fly queries to a solver that produces models of satisfiable existential T formulae. This is the first synthesis method for LTL modulo theories. Additionally, our method can produce adaptive responses which increases explainability and can improve runtime properties like performance. Our approach is applicable to both LTL modulo theories and LTLf modulo theories.

Microbiome abundance patterns as attractors and the implications for the inference of microbial interaction networks

Inferring microbial interaction networks from abundance patterns is an important approach to advance our understanding of microbial communities in general and the human microbiome in particular. Here we suggest discriminating two levels of information contained in microbial abundance data: (1) the quantitative abundance values and (2) the pattern of presences and absences of microbial organisms. The latter allows for a binary view on microbiome data and a novel interpretation of microbial data as attractors, or more precisely as fixed points, of a Boolean network.Starting from these attractors, our aim is to infer an interaction network between the species present in the microbiome samples. To accomplish this task, we introduce a novel inference method that combines the previously published ESABO (Entropy Shifts of Abundance vectors under Boolean Operations) method with an evolutionary algorithm. The key idea of our approach is that the inferred network should reproduce the original set of (observed) binary abundance patterns as attractors.We study the accuracy and runtime properties of this evolutionary method, as well as its behavior under incomplete knowledge of the attractor sets. Based on this theoretical understanding of the method we then show an application to empirical data.

SLearn: A Case for Task Sampling Based Learning for Cluster Job Scheduling

The ability to accurately estimate job runtime properties allows a scheduler to effectively schedule jobs. State-of-the-art online cluster job schedulers use history-based learning, which uses past job execution information to estimate the runtime properties of newly arrived jobs. However, with fast-paced development in cluster technology (in both hardware and software) and changing user inputs, job runtime properties can change over time, which lead to inaccurate predictions. In this paper, we explore the potential and limitation of real-time learning of job runtime properties, by proactively sampling and scheduling a small fraction of the tasks of each job. Such a task-sampling-based approach exploits the similarity among runtime properties of the tasks of the same job and is inherently immune to changing job behavior. Our analytical and experimental analysis of 3 production traces with different skew and job distribution shows that learning in space can be substantially more accurate. Our simulation and testbed evaluation on Azure of the two learning approaches anchored in a generic job scheduler using 3 production cluster job traces shows that despite its online overhead, learning in space reduces the average Job Completion Time (JCT) by 1.28×, 1.56×, and 1.32× compared to the prior-art history-based predictor.

GRuM — A flexible model-driven runtime monitoring framework and its application to automated aerial and ground vehicles

Runtime monitoring is critical for ensuring safe operation and for enabling self-adaptive behavior of Cyber-Physical Systems (CPS). Monitors are established by identifying runtime properties of interest, creating probes to instrument the system, and defining constraints to be checked at runtime. For many systems, implementing and setting up a monitoring platform can be tedious and time-consuming, as generic monitoring platforms do not adequately cover domain-specific monitoring requirements. This situation is exacerbated when the System under Monitoring (SuM) evolves, requiring changes in the monitoring platform. Most existing approaches lack support for the automated generation and setup of monitors for diverse technologies and do not provide adequate support for dealing with system evolution. In this paper, we present GRuM (Generating CPS Runtime Monitors), a framework that combines model-driven techniques and runtime monitoring, to automatically generate a customized monitoring platform for a given SuM. Relevant properties are captured in a Domain Model Fragment, and changes to the SuM can be easily accommodated by automatically regenerating the platform code. To demonstrate the feasibility and performance we evaluated GRuM against two different systems using TurtleBot robots and Unmanned Aerial Vehicles. Results show that GRuM facilitates the creation and evolution of a runtime monitoring platform with little effort and that the platform can handle a substantial amount of events and data.

Blockchain and trust-based clustering scheme for the IoV

The advent of the Internet of Vehicles (IoV) leads to the proliferation of services proposed for the users. Its adoption aims mainly to make driving more secure and enhance the users’ quality of experience. However, the deployment of multiple technologies that interact with each other brings out big security challenges. Indeed, it enlarges the attack vectors and surface. In the IoV ecosystem, cybersecurity issues can be driven from the security of communication links, security of devices, identity and liability, access control as well as privacy of drivers and vehicles. Trust management is one of the key mechanisms that can enforce the security of an IoV network. In a previous work (Hbaieb et al., 2021), we proposed a blockchain based trust management framework to enhance IoV security. Our framework showed good performance results. However, it was based on a centralized trust based approach. Thus, its performance is decreasing when dealing with effective scalability. Moreover, we did not focus on the energy consumption of the proposed model. In this paper, we propose an extension to enhance the highlighted limitations. For that, we are based on a decentralized trust process. We, also, introduce a clustering mechanism to construct our framework. Moreover, to take into account the quality of service (QoS) of our framework while enforcing security, we define our clustering process based on different parameters such as the trust value, the safety distance, and the energy factor. The evaluation of our proposal shows relevant results in terms of detection performance, communication overhead and runtime properties. The simulation results indicate that the formation of trustworthy clusters using blockchain reinforces the IoV reliability.

Refactoring embedded software: A study in healthcare domain

In embedded software industry, stakeholders usually promote run-time properties (e.g., performance, energy efficiency, etc.) as quality drivers, which in many cases leads to a compromise at the levels of design-time qualities (e.g., maintainability , reusability, etc.). Such a compromise does not come without a cost; since embedded systems need heavy maintenance cycles. To assure effective bug-fixing, shorten the time required for releasing updates, a refactoring of the software codebase needs to take place regularly. Objective: This study aims to investigate how refactorings are applied in ES industry; and propose a systematic approach that can guide refactoring through a 3-step process for refactoring: (a) planning; (b) design; and (c) evaluation. The aforementioned goals were achieved by conducting a single case study in a company that develops medical applications for bio-impedance devices; and follows a rather systematic refactoring process in periodic timestamps. Three data collection approaches have been used: surveys, interviews (10 practitioners), and artifact analysis (51 refactoring activities). The results of the study suggest that: (a) maintainability and reusability are the design-time quality attributes that motivate the refactoring of Embedded Software (ES), with 30% of the participants considering them as of “Very High” importance; (b) the refactorings that are most frequently performed are “Extract Method”, “Replace Magic Number with Constant” and “Remove Parameter”. We note that the “Extract Method” refactoring has an applicability of more than over 80%; and (c) to evaluate the refactoring process engineers use tools producing structural metrics, internal standards, and reviews. The outcomes of this study can be useful to both researchers and practitioners, in the sense that the former can focus their efforts on aspects that are meaningful to industry, whereas the latter are provided with a systematic refactoring process.

Learning Behavior Models for Hybrid Timed Systems

A tailored model of a system is the prerequisite for various analysis tasks, such as anomaly detection, fault identification, or quality assurance. This paper deals with the algorithmic learning of a system’s behavior model given a sample of observations. In particular, we consider real-world production plants where the learned model must capture timing behavior, dependencies between system variables, as well as mode switches—in short: hybrid system’s characteristics. Usually, such model formation tasks are solved by human engineers, entailing the well-known bunch of problems including knowledge acquisition, development cost, or lack of experience. Our contributions to the outlined field are as follows. (1) We present a taxonomy of learning problems related to model formation tasks. As a result, an important open learning problem for the domain of production system is identified: The learning of hybrid timed automata. (2) For this class of models, the learning algorithm HyBUTLA is presented. This algorithm is the first of its kind to solve the underlying model formation problem at scalable precision. (3) We present two case studies that illustrate the usability of this approach in realistic settings. (4) We give a proof for the learning and runtime properties of HyBUTLA.

Defining and measuring microservice granularity-a literature overview.

BackgroundMicroservices are an architectural approach of growing use, and the optimal granularity of a microservice directly affects the application’s quality attributes and usage of computational resources. Determining microservice granularity is an open research topic.MethodologyWe conducted a systematic literature review to analyze literature that addresses the definition of microservice granularity. We searched in IEEE Xplore, ACM Digital Library and Scopus. The research questions were: Which approaches have been proposed to define microservice granularity and determine the microservices’ size? Which metrics are used to evaluate microservice granularity? Which quality attributes are addressed when researching microservice granularity?ResultsWe found 326 papers and selected 29 after applying inclusion and exclusion criteria. The quality attributes most often addressed are runtime properties (e.g., scalability and performance), not development properties (e.g., maintainability). Most proposed metrics were about the product, both static (coupling, cohesion, complexity, source code) and runtime (performance, and usage of computational resources), and a few were about the development team and process. The most used techniques for defining microservices granularity were machine learning (clustering), semantic similarity, genetic programming, and domain engineering. Most papers were concerned with migration from monoliths to microservices; and a few addressed green-field development, but none address improvement of granularity in existing microservice-based systems.ConclusionsMethodologically speaking, microservice granularity research is at a Wild West stage: no standard definition, no clear development—operation trade-offs, and scarce conceptual reuse (e.g., few methods seem applicable or replicable in projects other than their initial proposal). These gaps in granularity research offer clear options to investigate on continuous improvement of the development and operation of microservice-based systems.

Markov chain analysis of evolutionary algorithms on OneMax function – From coupon collector's problem to (1 + 1) EA

The theoretical investigation of Evolutionary Algorithms (EAs) has increased our understanding of the computational mechanism of algorithms. OneMax is a test function most frequently and deeply studied in the field of EAs. In this work, a method is presented for describing the runtime properties of (1+1) EA on OneMax. This method is motivated by the work of Erdös and Rényi treating the coupon collector's problem. They showed that the success probability of the coupon collector's problem is given by a function of double exponential form, and that the number of uncollected coupons follows the Poisson distribution. Today, the double exponential function is called Gumbel function, which is one of three fundamental functions in extreme value statistics. We introduce an algorithm that is a variant of the (1+1) EA, First Order Evolutionary Algorithm (FO-EA). FO-EA takes into account only the effect of single-bit mutations in the (1+1) EA, which in general includes multiple-bit mutations. We modified the method of Erdös and Rényi to apply FO-EA. We apply the Gumbel distribution for calculating the success probability of the (1+1) EA on OneMax. This method turns out to give a sufficiently reliable estimation for success probabilities, even in the tail region.

Programming interactions in collective adaptive systems by relying on attribute-based communication

Collective adaptive systems are new emerging computational systems consisting of a large number of interacting components and featuring complex behaviour. These systems are usually distributed, heterogeneous, decentralised and interdependent, and are operating in dynamic and possibly unpredictable environments. Finding ways to understand and design these systems and, most of all, to model the interactions of their components, is a difficult but important endeavour. In this article we propose a language-based approach for programming the interactions of collective-adaptive systems by relying on attribute-based communication; a paradigm that permits a group of partners to communicate by considering their run-time properties and capabilities. We introduce AbC , a foundational calculus for attribute-based communication and show how its linguistic primitives can be used to program a sophisticated variant of the well-known problem of Stable Allocation in Content Delivery Networks. In our variant, content providers are assigned to clients based on collaboration and by taking into account the preferences of both parties in a fully anonymous and distributed settings. We also illustrate the expressive power of attribute-based communication by showing the natural encoding of group-based, publish/subscribe-based and channel-based communication paradigms into AbC .

Structural Decomposition Model for the Evolution of AS-Level Internet Topologies

Modeling Internet graphs at the autonomous-system (AS) level is helpful for recognizing and predicting the development trend of evolving Internet topology from a macro perspective. In contrast to the global statistical models such as the power-law distribution of node degrees, the structural decomposition models can more effectively represent the local connection. In this paper, we propose a structure-based model. Starting with the classification of links among the AS nodes, the proposed model partitions the core and periphery of Internet graphs into 16 atomic-level solid and dotted components. Additionally, the model captures the stable evolving features of these components based on the UCLA dataset that continuously explore Internet graphs over a long historic period from 2001 to 2015. Finally, according to the structure-based model, we design a new Internet-topology generator. Compared with the recently proposed generators, the advantages of our generator are as follows: (1) it accurately captures the structure decomposition property studied in this work, (2) it performs best on three statistical properties of the distance, assortativity coefficient, and maximum degree, and (3) it exhibits the best comprehensive performance in terms of runtime and multiple graph properties.

Run-time evaluation of architectures: A case study of diversification in IoT

Run-time properties of modern software system environments, such as Internet of Things (IoT), are a challenge for existing software architecture evaluation methods. Such systems are largely data-driven, characterized by their dynamism, unpredictability in operation, hyper-connectivity, and scale. Properties, such as performance, delayed delivery, and scalability, are acknowledged to pose great risk and are difficult to evaluate at design-time. Run-time evaluation could potentially be used to complement design-time evaluation, enabling significant deviations from the expected performance values to be captured. However, there are no systematic software architecture evaluation methods that intertwine and interleave design-time and run-time evaluation. This paper addresses this gap by proposing a novel run-time architecture evaluation method suited for systems that exhibit uncertainty and dynamism in their operation. Our method uses machine learning and cost-benefit analysis at run-time to continuously profile the architecture decisions made, to assess their added value. We demonstrate the applicability and effectiveness of this approach in the context of an IoT system architecture, where some architecture design decisions were diversified to meet Quality of Service (QoS) requirements. Our approach provides run-time assessment for these decisions which can inform deployment, refinement, and/or phasing-out decisions.

Distributed Reactive Programming for Reactive Distributed Systems

Context: The term reactivity is popular in two areas of research: programming languages and distributed systems. On one hand, reactive programming is a paradigm which provides programmers with the means to declaratively write event-driven applications. On the other hand, reactive distributed systems handle client requests in a timely fashion regardless of load or failures. Inquiry: Reactive programming languages and frameworks tailored to the implementation of distributed systems have previously been proposed. However, we argue that these approaches are ill fit to implement reactive distributed systems. Approach: We analyse state of the art runtimes for distributed reactive programming and identify two key issues with regards to reactive distributed systems. They rely on single, central points of coordination and/or assume a lack of partial failures in the systems they support. Knowledge: Based on our analysis we propose a novel runtime for distributed reactive programming languages and frameworks. This runtime supports reactive distributed systems by design. Grounding: We implement a proof of concept framework for reactive distributed systems in JavaScript which builds atop our runtime. Using this framework we implement a case study application which highlights the applicability of our approach. Moreover, we benchmark our runtime against a similar approach in order to showcase its runtime properties and we prove its correctness. Importance: This work aims to bridge the gap between two kinds of reactivity: reactive distributed systems and distributed reactive programming. Current distributed reactive programming approaches do not support reactive distributed systems. Our runtime is the first to bridge this reactivity gap: it allows for reactive distributed systems to be implemented using distributed reactive programming.

Model-driven Design-Runtime Interaction in Safety Critical System Development: an Experience Report.

Automotive, aerospace, industrial control, and railway systems are examples of application domains which are particularly characterized by the need for developing and managing critical systems. Model-driven engineering is recognized as an effective solution to leverage abstraction and automation while developing complex systems. One of the major and key challenges in the model-driven engineering of critical software systems is the integration of design and runtime aspects. Even though several methods and tools are available for performing measurements of runtime properties, the ability to trace them with design models is still limited. In the context of a real railway system, this paper presents a model-based approach that has been conceived to analyze runtime data (coming from different sensors), to produce corresponding traceability models and to automatically infer from them potential design issues that might need to be fixed in order to solve detected system malfunctionings.

Dependable Model-driven Development of CPS

Simulink is widely used for model-driven development (MDD) of cyber-physical systems. Typically, the Simulink-based development starts with Stateflow modeling, followed by simulation, validation, and code generation mapped to physical execution platforms. However, recent trends have raised the demands of rigorous verification on safety-critical applications to prevent intrinsic development faults and improve the system dependability, which is unfortunately challenging. Even though the constructed Stateflow model and the generated code pass the validation of Simulink Design Verifier and Simulink Polyspace, respectively, the system may still fail due to some implicit defects contained in the design model (design defect) and the generated code (implementation defects). In this article, we bridge the Stateflow-based MDD and a well-defined rigorous verification to reduce development faults. First, we develop a self-contained toolkit to translate a Stateflow model into timed automata, where major advanced modeling features in Stateflow are supported. Taking advantage of the strong verification capability of Uppaal, we can not only find bugs in Stateflow models that are missed by Simulink Design Verifier but also check more important temporal properties. Next, we customize a runtime verifier for the generated non-intrusive VHDL and C code of a Stateflow model for monitoring. The major strength of the customization is the flexibility to collect and analyze runtime properties with a pure software monitor, which offers more opportunities for engineers to achieve high reliability of the target system compared with the traditional act that only relies on Simulink Polyspace. In this way, safety-critical properties are both verified at the model level and at the consistent system implementation level with physical execution environment in consideration. We apply our approach to the development of a typical cyber-physical system-train communication controller based on the IEC standard 61375. Experiments show that more ambiguousness in the standard are detected and confirmed and more development faults and those corresponding errors that would lead to system failure have been removed. Furthermore, the verified implementation has been deployed on real trains.

: Cost Based Hardware Optimization for Asymmetric Multicore Processors

Heterogeneous Multiprocessors (HMPs) are popular due to their energy efficiency over Symmetric Multicore Processors (SMPs). Asymmetric Multicore Processors (AMPs) are a special case of HMPs where different kinds of cores share the same instruction set, but offer different power-performance trade-offs. Due to the computational-power difference between these cores, finding an optimal hardware configuration for executing a given parallel program is quite challenging. An inherent difficulty in this problem stems from the fact that the original program is written for SMPs. This challenge is exacerbated by the interplay of several configuration parameters that are allowed to be changed in AMPs. In this work, we propose a probabilistic method named CHOAMP to choose the bestavailable hardware configuration for a given parallel program. Selection of a configuration is guided by a user-provided run-time property such as energy-delay-product (EDP) and CHOAMP aspires to optimize the property in choosing a configuration. The core part of our probabilistic method relies on identifying the behavior of various program constructs in different classes of CPU cores in the AMP, and how it influences the cost function of choice. We implement the proposed technique in a compiler which automatically transforms a code optimized for SMP to run efficiently over an AMP, eliding requirement of any user annotations. CHOAMP transforms the same source program for different hardware configurations based on different user requirement. We evaluate the efficiency of our method for three different run-time properties: execution time, energy consumption, and EDP, in NAS Parallel Benchmarks for OpenMP. Our experimental evaluation shows that CHOAMP achieves an average of 65, 28, and 57 percent improvement over baseline HMP scheduling while optimizing for energy, execution time, and EDP, respectively.

A semantic theory of the Internet of Things

We propose a process calculus for modelling and reasoning on systems in the Internet of Things paradigm. Our systems interact both with the physical environment, via sensors and actuators, and with smart devices, via short-range and Internet channels. The calculus is equipped with a standard notion of labelled bisimilarity which is proved to be a coinductive characterisation of a well-known contextual equivalence. We use our semantic proof-methods to prove run-time properties of a non-trivial case study as well as system equalities.

Timing analysis for embedded systems using non-preemptive EDF scheduling under bounded error arrivals

Embedded systems consist of one or more processing units which are completely encapsulated by the devices under their control, and they often have stringent timing constraints associated with their functional specification. Previous research has considered the performance of different types of task scheduling algorithm and developed associated timing analysis techniques for such systems. Although preemptive scheduling techniques have traditionally been favored, rapid increases in processor speeds combined with improved insights into the behavior of non-preemptive scheduling techniques have seen an increased interest in their use for real-time applications such as multimedia, automation and control. However when non-preemptive scheduling techniques are employed there is a potential lack of error confinement should any timing errors occur in individual software tasks. In this paper, the focus is upon adding fault tolerance in systems using non-preemptive deadline-driven scheduling. Schedulability conditions are derived for fault-tolerant periodic and sporadic task sets experiencing bounded error arrivals under non-preemptive deadline scheduling. A timing analysis algorithm is presented based upon these conditions and its run-time properties are studied. Computational experiments show it to be highly efficient in terms of run-time complexity and competitive ratio when compared to previous approaches.

Scaling Properties of Parallel Applications to Exascale

A detailed profile of exascale applications helps to understand the computation, communication and memory requirements for exascale systems and provides the insight necessary for fine-tuning the computing architecture. Obtaining such a profile is challenging as exascale systems will process unprecedented amounts of data. Profiling applications at the target scale would require the exascale machine itself. In this work we propose a methodology to extrapolate the exascale profile from experimental observations over datasets feasible for today’s machines. Extrapolation models are carefully selected by means of statistical techniques and a high-level complexity analysis is included in the selection process to speed up the learning phase and to improve the accuracy of the final model. We extrapolate run-time properties of the target applications including information about the instruction mix, memory access pattern, instruction-level parallelism, and communication requirements. Compared to state-of-the-art techniques, the proposed methodology reduces the prediction error by an order of magnitude on the instruction count and improves the accuracy by up to 1.3\(\times \) for the memory access pattern, and by more than 2\(\times \) for the communication requirements.

An MPC-Based Approach to Provable System-Wide Safety and Liveness of Autonomous Ground Traffic

An important area of cyber-physical systems research is the development of smart ground transportation systems due to their potentially significant impact on safety, the economy, and the environment. We propose an approach based on model predictive control (MPC) for the development of provably collision free autonomous ground transportation systems, and present an autonomous intersection management framework. The MPC approach enables a vehicle to generate its own motion locally in time based on an optimization framework, incorporating constraints based on the states of other vehicles in the neighborhood, the speed limit of a road, the maximum values of acceleration and deceleration, etc. Safety and liveness of the traffic are however system-wide properties, not merely neighborhood properties, and the challenge is to augment this distributed optimization with coordination rules that guarantee overall system-wide safety as well as liveness of the traffic. We design two vehicle-to-vehicle (V2V) coordination rules, along with a vehicle-to-infrastructure rule, and establish the system-wide safety and liveness of the autonomous traffic based on each vehicle's MPC motion planner, operating in conjunction with an algorithm that orders vehicles according to their runtime properties. We also conduct a comparative simulation study of the throughput performance at an intersection of the above approach against another popular algorithm, the All-Way STOP.