Runtime Architecture Research Articles

Safe and secure system architectures for cyber-physical systems

Cyber-physical systems are at the core of our current civilization. Countless examples dominate our daily life and work, such as driverless cars that will soon master our roads, implanted medical devices that will improve many lives, and industrial control systems that control production and infrastructure. Because cyber-physical systems manipulate the real world, they constitute a danger for many applications. Therefore, their safety and security are essential properties of these indispensable systems. The long history of systems engineering has demonstrated that the system quality properties—such as safety and security—strongly depend on the underlying system architecture. Satisfactory system quality properties can only be ensured if the fundamental system architecture is sound! The development of dependable cyber-physical architectures in recent years suggests that two harmonical architectures are required: a design-time architecture and a run-time architecture. The design-time architecture defines and specifies all parts and relationships, assuring the required system quality properties. However, in today’s complex systems, ensuring all quality properties in all operating conditions during design time will never be possible. Therefore, an additional line of defense against safety accidents and security incidents is indispensable: This must be provided by the run-time architecture. The run-time architecture primarily consists of a protective shell that monitors the run-time system during operation. It detects anomalies in system behavior, interface functioning, or data—often using artificial intelligence algorithms—and takes autonomous mitigation measures, thus attempting to prevent imminent safety accidents or security incidents before they occur. This paper’s core is the protective shell as a run-time protection mechanism for cyber-physical systems. The paper has the form of an introductory tutorial and includes focused references.

Consent Verification Monitoring

Advances in personalization of digital services are driven by low-cost data collection and processing, in addition to the wide variety of third-party frameworks for authentication, storage, and marketing. New privacy regulations, such as the General Data Protection Regulation (GDPR) and the California Consumer Privacy Act, increasingly require organizations to explicitly state their data practices in privacy policies. When data practices change, a new version of the policy is released. This can occur a few times a year, when data collection or processing requirements are rapidly changing. Consent evolution raises specific challenges to ensuring GDPR compliance. We propose a formal consent framework to support organizations, data users, and data subjects in their understanding of policy evolution under a consent regime that supports both the retroactive and non-retroactive granting and withdrawal of consent. The contributions include (i) a formal framework to reason about data collection and access under multiple consent granting and revocation scenarios, (ii) a scripting language that implements the consent framework for encoding and executing different scenarios, (iii) five consent evolution use cases that illustrate how organizations would evolve their policies using this framework, and (iv) a scalability evaluation of the reasoning framework. The framework models are used to verify when user consent prevents or detects unauthorized data collection and access. The framework can be integrated into a runtime architecture to monitor policy violations as data practices evolve in real time. The framework was evaluated using the five use cases and a simulation to measure the framework scalability. The simulation results show that the approach is computationally scalable for use in runtime consent monitoring under a standard model of data collection and access and practice and policy evolution.

An Application of a Runtime Epistemic Probabilistic Event Calculus to Decision-making in e-Health Systems

AbstractWe present and discuss a runtime architecture that integrates sensorial data and classifiers with a logic-based decision-making system in the context of an e-Health system for the rehabilitation of children with neuromotor disorders. In this application, children perform a rehabilitation task in the form of games. The main aim of the system is to derive a set of parameters the child’s current level of cognitive and behavioral performance (e.g., engagement, attention, task accuracy) from the available sensors and classifiers (e.g., eye trackers, motion sensors, emotion recognition techniques) and take decisions accordingly. These decisions are typically aimed at improving the child’s performance by triggering appropriate re-engagement stimuli when their attention is low, by changing the game or making it more difficult when the child is losing interest in the task as it is too easy. Alongside state-of-the-art techniques for emotion recognition and head pose estimation, we use a runtime variant of a probabilistic and epistemic logic programming dialect of the Event Calculus, known as the Epistemic Probabilistic Event Calculus. In particular, the probabilistic component of this symbolic framework allows for a natural interface with the machine learning techniques. We overview the architecture and its components, and show some of its characteristics through a discussion of a running example and experiments.

Research on internetware: Review and prospect

<p indent="0mm">Software is the core component of IT industry and an important “infrastructure” that supports social operations in the digital economy era. Since the 21st century, the internet has evolved into a global ubiquitous computing environment and open platform. Its open, dynamic, and uncontrollable nature requires the corresponding changes in the basic form and characteristics of software, the conceptual framework, and the logical connotation, and thus leads to substantial challenges to software theory, methods, and technologies. In 2000, researchers from China proposed the term “internetware”, which indicates a new software paradigm for the internet computing. After more than <sc>20 years</sc> of efforts, a series of important research achievements have been made in aspects of the basic model, development methodology, runtime support, quality assessment and assurance of internetware, and resulted in systematic innovation results and produced a wide range of academic and industrial impacts. In internetware, the software model consists of a set of autonomous software entities distributed and/or decentralized over the internet and other extensions like internet of things and 4G/5G, together with a set of connectors for enabling collaborations among these entities in various ways. Internetware software entities are able to sense dynamic changes of the underlying environments, and continuously adapt to these changes by means of structural and behavioral maintenance and evolution. From the micro perspective, internetware software entities collaborate with each other on demand and on the fly. From the macro perspective, the entities can self-organize to form an application or community of interest and even decentralized autonomous organizations. As a result, the development and evolution of a software application with internetware can be viewed as continuous and iterative composition of various “disordered” resources into “ordered” software applications. Thus, software development with internetware is a process being bottom-up, inside-out, spiral, and to some extent, similar with the complex adaptive systems. For example, the internetware paradigm proposed the theory of software architecture modeling (called ABC methodology) covering the whole life-cycle, where the core artifacts and activities of every single stage are unified into the software architecture model and its iterative refinement and transformation. In this way, the internetware paradigm greatly improves the efficiency and quality of software development and evolution. In addition, the internetware paradigm expands the software architecture from the development phase to the runtime, by proposing the concept of runtime software architecture (RSA). The RSA has been widely applied for a large number of information “silo” systems to enable the functionality and data interoperability. This solution is a significantly disruptive technical invention, or namely the “black box” mode, based on the client-driven resource reflection mechanism to achieve automatic recovery of the system runtime architecture and automatic generation of data access interfaces. Compared to the traditional “white box” interoperability solution, the internetware paradigm eliminates the need of accessing source code, documentation, and original development team, and improves the interoperability efficiency between information silos, with more than 100X acceleration. This article reviews the research and practice of internetware from the perspective of software paradigm, following the internet computing environment and its extensions as a clue. It also discusses the future research outlook of internetware, especially for the ubiquitous computing environments and data centric technologies.

Ket Quantum Programming

Quantum programming languages (QPL) fill the gap between quantum mechanics and classical programming constructions, simplifying the development of quantum applications. However, most QPL addresses the inherent quantum programming problem, neglecting quantum computer implementation constraints. We present a runtime architecture for classical-quantum execution that mitigates the limitation of interaction between classical and quantum computers originated from the cloud-based model of quantum computation provided by several vendors, which implies a quantum computer processing in batch. In the proposed runtime architecture, we introduce (i) runtime quantum code generation to enable generic quantum programming and dynamic quantum execution; and (ii) the concept of futures to handle dynamic interaction between classical and quantum computers. To support our proposal, we have implemented the Ket Quantum Programming framework that features a Python-embedded classical-quantum programming language named Ket, the C++ quantum programming library Libket, and Ket Bitwise (quantum computing) Simulator. The last one improves over the bitwise representation, making the simulation time not dependent on the number of qubits but the amount of superposition and entanglement of simulation.

Research on Dynamic Optimization Method of Embedded Multi-core Performance based on Runtime

: Embedded multi-core systems often show special limitations in sharing resources and storage capacity, which will lead to the reduction of parallel efficiency due to bandwidth, data competition and other factors. In this paper, a run-time optimization framework is proposed to dynamically and adaptively adjust parallel strategies according to the structure of different parallel programs. On the one hand, the performance analysis model of a parallel program structure is established to get the number of threads during the best performance. On the other hand, in view of the load imbalance in parallel thread execution, an adaptive dynamic scheduling algorithm is proposed to dynamically select the size of the scheduling block. Experimental results show that the proposed dynamic scheduling strategy can improve program performance and achieve improvement of the performance of the embedded multi-core system. Background: Embedded multi-core systems often have special limitations in sharing resources and storage capacity. These limitations often lead to parallel programs running with lower parallel efficiency due to bandwidth, data competition and other factors. Objective: In order to improve the performance of embedded multi-core systems, parallel strategies can be adjusted dynamically and adaptively for different parallel program structures. Methods: A control mechanism of the thread count based on runtime information feedback is proposed, which enables the system to dynamically select the number of threads when the program runs best according to the structure characteristics of parallel programs. Then, an adaptive dynamic scheduling algorithm is proposed to solve the load imbalance in parallel program execution. Results: An optimization framework based on run-time architecture is presented, which consists of two parts: performance monitoring and control interface. It can take corresponding optimization strategies according to the running state of parallel programs. Conclusion: The performance of the embedded multi-core system is improved.

Empirical Evaluation of Diagnostic Algorithm Performance Using a Generic Framework

A variety of rule-based, model-based and datadriven techniques have been proposed for detection and isolation of faults in physical systems. However, there have been few efforts to comparatively analyze the performance of these approaches on the same system under identical conditions. One reason for this was the lack of a standard framework to perform this comparison. In this paper we introduce a framework, called DXF, that provides a common language to represent the system description, sensor data and the fault diagnosis results; a run-time architecture to execute the diagnosis algorithms under identical conditions and collect the diagnosis results; and an evaluation component that can compute performance metrics from the diagnosis results to compare the algorithms. We have used DXF to perform an empirical evaluation of 13 diagnostic algorithms on a hardware testbed (ADAPT) at NASA Ames Research Center and on a set of synthetic circuits typically used as benchmarks in the model-based diagnosis community. Based on these empirical data we analyze the performance of each algorithm and suggest directions for future development.

Using Architectural Runtime Verification for Offline Data Analysis

Analyzing runtime behavior as part of debugging complex component-based systems used in the vehicle industry is an important aspect of the integration process. It is a laborious task that involves many manual steps. One reason for this is that, as of today, the analysis is usually not performed on the architecture level, where the system has initially been designed. Instead, it relies on source code debugging or visualizing signals and events. With an ever-growing complexity of such systems, it becomes increasingly difficult to find errors that manifest at integration level, i.e., when the components interact with each other in a complex environment. Architectural Runtime Verification (ARV) is an approach specifically designed for the integrator—a generic way to analyze system behavior on architecture level using the principles of Runtime Verification. This paper draws on our initial publication. It provides further details and an evaluation of the ideas using a database hosted in the cloud.

A decentralized approach for discovering runtime software architectural models of distributed software systems

Abstract Context: Runtime software architectural models of self-adaptive systems are needed for making adaptation decisions in architecture-based self-adaptive systems. However, when these systems are distributed and highly dynamic, there is an added need to discover the system’s software architecture model at runtime. Current methods of runtime architecture discovery use a centralized approach, in which the process is carried out from a single location. These methods are inadequate for large distributed software systems because they do not scale up well and have a single point of failure. Objective and Method: This paper describes DeSARM (Decentralized Software Architecture discoveRy Mechanism), a completely decentralized and automated approach, based on gossiping and message tracing, for runtime discovery of software architecture models of distributed software systems. DeSARM is able to identify at runtime important architectural characteristics such as components and connectors, in addition to synchronous and asynchronous communication patterns. Furthermore, through its use of gossiping, DeSARM exhibits the properties of scalability, global consistency among participating nodes, and resiliency to failures. This paper demonstrates DeSARM’s properties and answers key research questions through experimentation with software architectures of varying sizes and complexities executing within a computer cluster. Results: DeSARM enables the decentralized discovery of runtime software architectural models of distributed software systems while exhibiting the properties of scalability, global consistency among participating nodes and resiliency to failures. Scalability is achieved through DeSARM’s ability to successfully discover software architectures of increasing sizes and complexities executing across node counts of increasing sizes. Global consistency among participating nodes is achieved by each node within the system discovering the complete software architecture independently but in coordination with each other. Finally, resiliency to failures is achieved by DeSARM successfully discovering the software architecture of the system in the presence of component failures.

Online Reconfiguration of Distributed Robot Control Systems for Modular Robot Behavior Implementation

The use of autonomous robots in areas that require executing a broad range of different tasks is currently hampered by the high complexity of the software that adapts the robot controller to different situations the robot would face. Current robot software frameworks facilitate implementing controllers for individual tasks with some variability, however, their possibilities for adapting the controllers at runtime are very limited and don’t scale with the requirements of a highly versatile autonomous robot. With the software presented in this paper, the behavior of robots is implemented modularly by composing individual controllers, between which it is possible to switch freely at runtime, since the required transitions are calculated automatically. Thereby the software developer is relieved of the task to manually implement and maintain the transitions between different operational modes of the robot, what largely reduces software complexity for larger amounts of different robot behaviors. The software is realized by a model-based development approach. We will present the metamodels enabling the modeling of the controllers as well as the runtime architecture for the management of the controllers on distributed computation hardware. Furthermore, this paper introduces an algorithm that calculates the transitions between two controllers. A series of technical experiments verifies the choice of the underlying middleware and the performance of online controller reconfiguration. A further experiment demonstrates the applicability of the approach to real robotics applications.

Architectural runtime models for integrating runtime observations and component-based models

Keeping track of modern software applications while dynamically changing requires strong interaction of evolution activities on development level and adaptation activities on operation level. Knowledge about software architecture is key for both, developers while evolving the system and operators while adapting the system. Existing architectural models used in development differ from those used in operation in terms of purpose, abstraction and content. Consequences are limited reuse of development models during operation, lost architectural knowledge and limited phase-spanning consideration of software architecture.In this paper, we propose modeling concepts of the iObserve approach to align architectural models used in development and operation. We present a correspondence model to bridge the divergent levels of abstraction between implementation artifacts and component-based architectural models. A transformation pipeline uses the information stored in the correspondence model to update architectural models based on changes during operation. Moreover, we discuss the modeling of complex workload based on observations during operation. In a case study-based evaluation, we examine the accuracy of our models to reflect observations during operation and the scalability of the transformation pipeline. Evaluation results show the accuracy of iObserve. Furthermore, evaluation results indicate iObserve adequately scales for some cases but shows scalability limits for others.

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.

Dynamically Scalable Distributed Virtual Framework Based on Agents and Pub/Sub Pattern for IoT Media Data

The Internet of Things (IoT) continues to expand; as daily new smart-devices are connected to Internet and adding to a deluge of data created by our society. Compounding the challenges is that this data is very heterogeneous, including device or human activity trace data, structured data, sensor information, and media data. The computing needs for the IoT continue to rise in terms of scalable compute power, storage, and complex data processing pipelines to accommodate these diverse sources of data. For this reason, it becomes essential to develop a flexible framework that is able to efficiently manage the IoT data in a real-time and scalable approach. In this paper, we propose a novel framework to handle IoT data. Our framework is dynamically extensible, lightweight, resources efficient, and has the ability to handle stream data as well as batch data. We leverage autonomous agents along with the publish-subscribe pattern to achieve a run-time extensible, event-driven, and high-performance computational architecture. Additionally, we have incorporated localized and centralized databases into the framework to support structured and unstructured data for compute processing and analytical tasks. We have implemented the proposed framework and evaluated its performance using a visual object-detection case study on both a local cluster and within cloud-computing infrastructure. Our analysis shows that this framework utilizes the CPU, memory, and network resources efficiently. Additionally, the framework can scale horizontally as adding more processing nodes reduces the time and increases the goodput.

The Agamid design-space exploration framework

The emergence of many-core processors raises novel demands to system design. Power-limitations and abundant parallelism require for efficient and scalable run-time management. The integration of dedicated hardware to enhance the performance of the run-time management system is gaining an increasing importance. But the design of a run-time manager for many-core generally suffers from exhaustive evaluation time. Previous works do not address for the required flexibility or do not address for reasonable evaluation time of the simulation framework. We propose the novel simulation framework Agamid to foster the development and evaluation of hardware enhanced run-time management for many-core. Our transaction-level framework performs design point evaluation of hardware enhanced run-time management for many-core at the timescale of seconds. We use a hybrid simulation approach considering the run-time management and the user application at different levels of abstraction. The framework provides a generic run-time manager to compare arbitrary management systems and HW/SW partitionings. The implementation of the run-time manager facilitates direct execution at the host machine and a detailed synchronization model. Agamid applies user application workloads by means of transaction-based task graphs. An extendable system-call interface allows arbitrary interaction between the user application and the run-time management system. The thorough calibration of the RTM timing model enables reasonable approximations of the management overhead. Our evaluation considers the accuracy, wall-time and design space exploration capabilities of Agamid. Our findings substantiate the usefulness to integrate the modeling of the run-time management, hardware architecture and user application into a single transaction-level framework.

Architectural Run-time Models for Performance and Privacy Analysis in Dynamic Cloud Applications

Building software systems by composing third-party cloud services promises many benefits such as flexibility and scalability. Yet at the same time, it leads to major challenges like limited control of third party infrastructures and runtime changes which mostly cannot be foreseen during development. While previous research focused on automated adaptation, increased complexity and heterogeneity of cloud services as well as their limited observability, makes evident that we need to allow operators (humans) to engage in the adaptation process. Models are useful for involving humans and conducting analysis, e.g. for performance and privacy. During operation the systems often drifts away from its design-time models. Run-time models are kept insync with the underlying system. However, typical run-time models are close to an implementation level of abstraction which impedes understandability for humans. In this vision paper, we present the iObserve approach to target aforementioned challenges while considering operationlevel adaptation and development-level evolution as two mutual interwoven processes. Central to this perception is an architectural run-time model that is usable for automatized adaptation and is simultaneously comprehensible for humans during evolution. The run-time model builds upon a technology-independent monitoring approach. A correspondence model maintains the semantic relationships between monitoring outcomes and architecture models. As an umbrella a megamodel integrates design-time models, code generation, monitoring, and run-time model update. Currently, iObserve covers the monitoring and analysis phases of the MAPE control loop. We come up with a roadmap to include planning and execution activities in iObserve.

SoPC Self-Integration Mechanism for Seamless Architecture Adaptation to Stream Workload Variations

Field-programmable gate arrays are becoming one of the implementation platforms of choice for computationally intensive embedded applications, such as multimode stream processors; such systems often exhibit poor cost-efficiency as various system modules can be idle, based on operating mode. This problem can be addressed through the use of reconfigurable computing, which allows underlying logic resources to be shared among system modules; using this approach, an application and mode specific processor can be generated at run-time. However, this generation process can interfere with application workloads; this is particularly true in the case of high data-rate stream processors. To address this problem, this brief presents a system-on-programmable-chip self-integration mechanism aimed at reconfigurable stream processors. The proposed mechanism is implemented using a distributed architecture and the multimode adaptive collaborative reconfigurable self-organized system framework. The mechanism arranges configuration, link establishment, and scheduling tasks around the stream workload, which allows for seamless run-time architecture adaptation. When compared with traditional approaches, based on central, instruction-based sequential processors, the proposed approach is shown to offer a faster (up to 10 times) link establishment and the scheduling capabilities; more importantly, the proposed mechanism can offer seamless run-time architecture adaptation by allowing the overlap of processing and configuration tasks.

Picos: A hardware runtime architecture support for OmpSs

OmpSs is a programming model that provides a simple and powerful way of annotating sequential programs to exploit heterogeneity and task parallelism based on runtime data dependency analysis, dataflow scheduling and out-of-order task execution; it has greatly influenced Version 4.0 of the OpenMP standard. The current implementation of OmpSs achieves those capabilities with a pure-software runtime library: Nanos++. Therefore, although powerful and easy to use, the performance benefits of exploiting fine-grained (pico) task parallelism are limited by the software runtime overheads. To overcome this handicap we propose Picos, an implementation of the Task Superscalar (TSS) architecture that provides hardware support to the OmpSs programming model. Picos is a novel hardware dataflow-based task scheduler that dynamically analyzes inter-task dependencies and identifies task-level parallelism at run-time. In this paper, we describe the Picos Hardware Design and the latencies of the main functionality of its components, based on the synthesis of their VHDL design. We have implemented a full cycle-accurate simulator based on those latencies to perform a design exploration of the characteristics and number of its components in a reasonable amount of time. Finally, we present a comparison of the Picos and Nanos++ runtime performance scalability with a set of real benchmarks. With Picos, a programmer can achieve ideal scalability using aggressive parallel strategies with a large number of fine granularity tasks.

A middleware platform for the dynamic evolution of distributed component-based systems

In this paper, we present a middleware platform that supports the dynamic evolution of distributed component-based systems. It leverages the concept of ontologies to model the context of a system and an intrinsic mechanism is integrated to causally connect the dynamic architecture specification to the running system implementation. The ontological modeling covers both the environmental and the architectural knowledge using semantic data modeling. The intrinsic mechanism can automatically derive a run-time polymorphic architecture object to coordinate the involved components. The ontology based contextual representation and the polymorphic architecture-driven dynamic evolution are the two underpinnings of the platform. A scenario application--including the two primitive evolution actions--with the performance analysis is discussed to illustrate the feasibility.

Exploiting Dynamic Information in IDEs Improves Speed and Correctness of Software Maintenance Tasks

Modern IDEs such as Eclipse offer static views of the source code, but such views ignore information about the runtime behavior of software systems. Since typical object-oriented systems make heavy use of polymorphism and dynamic binding, static views will miss key information about the runtime architecture. In this paper, we present an approach to gather and integrate dynamic information in the Eclipse IDE with the goal of better supporting typical software maintenance activities. By means of a controlled experiment with 30 professional developers, we show that for typical software maintenance tasks, integrating dynamic information into the Eclipse IDE yields a significant 17.5 percent decrease of time spent while significantly increasing the correctness of the solutions by 33.5 percent. We also provide a comprehensive performance evaluation of our approach.

Architecture of a Framework for Providing Information Services for Public Transport

This paper presents OnRoute, a framework for developing and running ubiquitous software that provides information services to passengers of public transportation, including payment systems and on-route guidance services. To achieve a high level of interoperability, accessibility and context awareness, OnRoute uses the ubiquitous computing paradigm. To guarantee the quality of the software produced, the reliable software principles used in critical contexts, such as automotive systems, are also considered by the framework. The main components of its architecture (run-time, system services, software components and development discipline) and how they are deployed in the transportation network (stations and vehicles) are described in this paper. Finally, to illustrate the use of OnRoute, the development of a guidance service for travellers is explained.