Maintenance of embedded systems: supporting program comprehension using dynamic analysis

An integrated real-time tool set is described that consists of a schedulability analyzer and a real-time monitor/debugger for the ARTS kernel, which is being built for a distributed real-time testbed. The schedulability analyzer, called Scheduler 1-2-3, is an X11 window-based interactive tool and can verify whether the given real-time tasks can meet their deadlines under a specific scheduling policy. An advanced real-time monitor, ARM, also runs on the X11 window and visualizes the target system's runtime behavior in real time. ARM can be used with Scheduler 1-2-3 to analyze simulated runs and its monitorability. >

With the growing complexity of complex software-intensive systems, some new features emerge such as logical complexity, boundary erosion and failure normalization, which bring new challenges for software dependability assurance. As a result, there is urgent necessity to analyze the failure mechanism of these systems in order to ensure the dependability of complex software-intensive systems. Research indicates that because of the emerging new features, the failure mechanism of complex software-intensive systems is related closely to the system's runtime states and behaviors. But direct analysis of failure mechanism on actual complex software-intensive systems is costly and nearly impossible because of their large scale. So failure mechanism analysis was normally performed on abstract models of real systems. However, current modelling methods are insufficient for describing the system's internal interaction, software/hardware interaction behavior, runtime behavior comprehensively. So it is necessary to propose a new modelling method to support the description of these new features. This paper proposes a method for constructing runtime models for complex software-intensive systems which takes into consideration internal interaction behavior, interaction behavior between software and hardware on system boundary as well as dynamic runtime behavior. The proposed method includes a static structure model to describe the static structure property of the system, a software/hardware interaction model to describe the interaction characteristics between hardware and software on system boundary and a dynamic runtime behavior model to describe the dynamic features of runtime behavior formally. An example is provided to demonstrate how to use the proposed method and its implication for failure mechanism analysis in complex software-intensive systems is discussed.

: Optimally partitioning application and file system functionality within a cluster of clients and servers is a difficult problem due to dynamic variations in application behavior, resource availability and workload mixes. This paper presents ABACUS, a run-time system that monitors and dynamically changes function placement for applications that manipulate large data sets. Several examples of data-intensive workloads are used to show the importance of proper function placement and its dependence on dynamic runtime characteristics, with performance differences frequently reaching 2-10X. We evaluate how well the ABACUS prototype adapts to run-time system behavior, including both long-term variation (e.g., filter selectivity) and short-term variation (e.g.,multi-phase applications and inter-application resource contention). Our experiments with ABACUS indicate that it is possible to adapt in all of these situations and that the adaptation converges most quickly in those cases where the performance impact is most significant.

This paper considers the problem of runtime system deviations from requirements specifications. Such deviations may arise from lack of anticipation of possible behaviors of environment agents at specification time, or from evolving conditions in this environment. We discuss an architecture and a development process for monitoring system requirements at runtime to reconcile the requirements and the system's runtime behavior.This process is deployed on three scenarios of requirements-execution reconciliation for the Meeting Scheduler system. The work builds on our previous work on goal-driven requirements engineering and on runtime requirements monitoring.

Recently, more attention is paid to the researches and practices on how to use software architecture in software maintenance and evolution to reduce their complexity and cost. The key in such architecture-based maintenance and evolution is to recover software architecture from existing systems. Almost all studies on architecture recovery focus on analyzing the source code and other documents. Such recovered software architecture can hardly capture runtime states and behaviors of the system. At the same time, current work pays little attention on how to change the system directly via manipulating the recovered software architecture. This paper presents a novel approach to recovering software architecture from component based systems at runtime and changing the runtime systems via manipulating the recovered software architecture. Containing much more details than the designed software architecture, the recovered software architecture can accurately and thoroughly describe the actual states and behaviors of the runtime system. It can be described formally with the extension of traditional architecture description language, which enables the recovered software architecture to absorb the semantics embedded in the designed software architecture. The recovered software architecture can be represented as multiple views so as to help different users to control the complexity from different concerns. Based on the reflective ability of the component framework, the recovered software architecture is up-to-date at any time and changes made on it will immediately lead to the corresponding changes in the runtime system. The approach presented in this paper is demonstrated on PKUAS, a reflective J2EE (Java 2 Platform Enterprise Edition) application server, and the performance is also evaluated.

As of 2011, the Android market has already surpassed the Apple App Store in number of applications. Along with this increase in applications, also comes an increase in number of malicious applications. In response, there has been extensive research done with behavioral analysis and detection methods using system calls, CPU usage, and anomaly-based detection. In this paper, we extend upon these previous works by using logcat and strace outputs to generate runtime datasets of both malicious and benign applications. Using these datasets, we generate feature sets to be used for classification. We test the effectiveness of both a Random Forest classifier and a Support Vector Machine on this feature set. We see the Random Forest classifier perform well with true positive rates exceeding 90% while maintaining a false positive rate less than 6%.

The authors present a software-based approach that uses run-time program behavior to minimize the performance overhead in signature control flow checking. In general, for both RISC (reduced-instruction-set-computer) and CISC (complex-instruction-set-computer) architectures, it is found that using run-time information can reduce the performance overhead by 50%. For the MC68000, the performance overhead for adding justifying and reference signatures to the program code is approximately 2.8%. In addition to optimizing the performance, the authors' approach does not increase the hardware complexity of the monitor. Furthermore, an O(N/sup 2/) algorithm which inserts justifying signatures on the arcs of the program control flow graph with N nodes is presented. It is shown that the algorithm complexity of previous schemes which insert justifying signatures in the program nodes is exponential. >

IntroLib: Efficient and transparent library call introspection for malware forensics

Behavioural analysis has become an important method of today's malware research. Malicious software is executed inside a controlled environment where its runtime behaviour can be studied. Recently, we proposed the concept of not only observing individual executables but a computer system as a whole. The basic idea is to identify malware by detecting anomalies in the way a system behaves. In this paper we discuss our methodology for empirical malware research and highlight its strengths and limitations. Furthermore, we explain the challenges we faced during our research and describe our lessons learned.

Buffer overflow is possibly the most well-known memory issue. It can cause erratic program behavior, such as incorrect outputs and crashes, and can be exploited to issue security attacks. Detecting buffer overflows has drawn significant research attention for almost three decades. However, the prevalence of security attacks due to buffer overflows indicates that existing tools are still not widely utilized in production environments, possibly due to their high performance overhead or limited effectiveness. This paper proposes CSOD, a buffer overflow detection tool designed for the production environment. CSOD proposes a novel context-sensitive overflow detection technique that can dynamically adjust its detection strategy based on the behavior of different allocation calling contexts, enabling it to effectively detect overflows in millions of objects via four hardware watchpoints. It can correctly report root causes of buffer over-writes and over-reads, without any additional manual effort. Furthermore, CSOD only introduces 6.7% performance overhead on average, which makes it appealing as an always-on approach for production software.

Reproducing executions of multithreaded programs is very challenging due to many intrinsic and external non-deterministic factors. Existing RnR systems achieve significant progress in terms of performance overhead, but none targets the in-situ setting, in which replay occurs within the same process as the recording process. Also, most existing work cannot achieve identical replay, which may prevent the reproduction of some errors. This paper presents iReplayer, which aims to identically replay multithreaded programs in the original process (under the "in-situ" setting). The novel in-situ and identical replay of iReplayer makes it more likely to reproduce errors, and allows it to directly employ debugging mechanisms (e.g. watchpoints) to aid failure diagnosis. Currently, iReplayer only incurs 3% performance overhead on average, which allows it to be always enabled in the production environment. iReplayer enables a range of possibilities, and this paper presents three examples: two automatic tools for detecting buffer overflows and use-after-free bugs, and one interactive debugging tool that is integrated with GDB.

Program Control Language: a programming language for adaptive distributed applications

Live testing is used in the context of continuous delivery and deployment to test changes or new features in the production environment. This includes canary releases, dark launches, A/B tests, and gradual rollouts. Oftentimes, multiple of these live testing practices need to be combined (e.g., running an A/B test after a dark launch). Manually administering such multi-phase live testing strategies is a daunting task for developers or release engineers. In this paper, we introduce a formal model for multi-phase live testing, and present Bifrost as a Node.js based prototype implementation that allows developers to define and automatically enact complex live testing strategies. We extensively evaluate the runtime behavior of Bifrost in three rollout scenarios of a microservice-based case study application, and conclude that the performance overhead of our prototype is at or below 8 ms for most scenarios. Further, we show that more than 100 parallel strategies can be enacted even on cheap public cloud instances.

To provide an overview of the systems being used to identify and predict clinical deterioration in hospitalised patients, with focus on the current and future role of artificial intelligence (AI). There are five leading AI driven systems in this field: the Advanced Alert Monitor (AAM), the electronic Cardiac Arrest Risk Triage (eCART) score, Hospital wide Alert Via Electronic Noticeboard, the Mayo Clinic Early Warning Score, and the Rothman Index (RI). Each uses Electronic Patient Record (EPR) data and machine learning to predict adverse events. Less mature but relevant evolutions are occurring in the fields of Natural Language Processing, Time and Motion Studies, AI Sepsis and COVID-19 algorithms. Research-based AI-driven systems to predict clinical deterioration are increasingly being developed, but few are being implemented into clinical workflows. Escobar et al. (AAM) provide the current gold standard for robust model development and implementation methodology. Multiple technologies show promise, however, the pathway to meaningfully affect patient outcomes remains challenging.

This essay poses a novel integrative environmental health promotion (EHP) framework inclusive of spiritual tenets to increase interdisciplinary science as well as public engagement for improved people, place, and planetary (3P) health outcomes. Environmental public health professionals have typically relied upon quantitative scientific evidence related to negative human health outcomes from toxic exposures. Environmental health lags behind more progressive mixed-methods research frameworks leveraging health promotion and 3P health initiatives. This essay argues for a novel integrative EHP framework to encourage more mixed-methods research based on merging an integrative health (body-mind-spirit) perspective and the public health ecological model. Using a three-dimensional Cartesian Coordinate System, the author developed a visual integrative EHP framework with the future ability to record, interpret, and report data with units of measure in three dimensions rather than the traditional x- and y-axis variable relationships. The long-term goal is to engage researchers, study participants, and the general public in exploring new 3P health research and outcomes inclusive of the spiritual axis to leverage more scientific evidence for the care and nurturing of our common home as a basic tenet of civil society.