Runtime Tools Research Articles

On Processing Extreme Data

Extreme Data is an incarnation of Big Data concept distinguished by the massive amounts of data that must be queried, communicated and analyzed in near real-time by using a very large number of memory or storage elements and exascale computing systems. Immediate examples are the scientific data produced at a rate of hundreds of gigabits-per-second that must be stored, filtered and analyzed, the millions of images per day that must be analyzed in parallel, the one billion of social data posts queried in real-time on an in-memory components database. Traditional disks or commercial storage nowadays cannot handle the extreme scale of such application data. Following the need of improvement of current concepts and technologies, we focus in this paper on the needs of data intensive applications running on systems composed of up to millions of computing elements (exascale systems). We propose in this paper a methodology to advance the state-of-the-art. The starting point is the definition of new programming paradigms, APIs, runtime tools and methodologies for expressing data-intensive tasks on exascale systems. This will pave the way for the exploitation of massive parallelism over a simplified model of the system architecture, thus promoting high performance and efficiency, offering powerful operations and mechanisms for processing extreme data sources at high speed and/or real time.

Developing tools as plug‐ins: TOPI 2012 special issue

SUMMARYOur knowledge as to how to solve software engineering problems is increasingly being encapsulated in tools. These tools are at their strongest when they operate in a preexisting development that can provide integration with existing elements such as compilers, debuggers, profilers, and visualizers as well as numerous other development and, often, runtime tools. However, building tools as plug‐ins can be challenging and raise many questions: How do they interact with the core environment? How do they interact with other existing plug‐ins, especially as each developer may choose a different set of plug‐ins. How can we share tools across different and future core development environments? How do we evaluate the usefulness of the tools? The series of workshops on Developing Tools as Plug‐ins (TOPI) tries to address these questions. Researchers are invited to present position papers spotting the medium‐term and long‐term challenges of developing tools as plug‐ins as well as research contributions identifying recent successful tools as plug‐ins, characteristics of good plug‐ins and reports of the main difficulties in implementing plug‐ins in current platforms. This issue includes extended versions of the best papers presented at TOPI 2012. Copyright © 2014 John Wiley & Sons, Ltd.

Developing tools as plug‐ins: TOPI 2011 special issue editorial

SUMMARYOur knowledge of how to solve software engineering problems is increasingly being encapsulated in tools. These tools are at their strongest when they operate in a pre‐existing integrated development environment (IDE). This approach allows integration with existing elements such as compilers, debuggers, profilers, visualizers, and numerous other development and, often, runtime tools. Tools and environments to increase software quality and productivity have always been an important aspect of software engineering. A plug‐in is a modern way for incrementally adding new tools into existing environments. However, building tools as plug‐ins can be challenging. How do they interact with the core environment? How do they interact with one another ‐ especially since each developer may choose a different set of plug‐ins? How can we share tools across different, and future, core development environments?

Component-based software for dynamic configuration and control of computer assisted intervention systems

This paper presents the rationale for the use of a component-based architecture for computer-assisted intervention (CAI) systems, including the ability to reuse components and to easily develop distributed systems. We introduce three additional capabilities, however, that we believe are especially important for research and development of CAI systems. The first is the ability to deploy components among different processes (as conventionally done) or within the same process (for optimal real-time performance), without requiring source-level modifications to the component. This is particularly relevant for real-time video processing, where the use of multiple processes could cause perceptible delays in the video stream. The second key feature is the ability to dynamically reconfigure the system. In a system composed of multiple processes on multiple computers, this allows one process to be restarted (e.g., after correcting a problem) and reconnected to the rest of the system, which is more convenient than restarting the entire distributed application and enables better fault recovery. The third key feature is the availability of run-time tools for data collection, interactive control, and introspection, and offline tools for data analysis and playback. The above features are provided by the open-source cisst software package, which forms the basis for the Surgical Assistant Workstation (SAW) framework. A complex computer-assisted intervention system for retinal microsurgery is presented as an example that relies on these features. This system integrates robotics, stereo microscopy, force sensing, and optical coherence tomography (OCT) imaging to transcend the current limitations of vitreoretinal surgery.

Performance Analysis Framework for High-Level Language Applications in Reconfigurable Computing

High-Level Languages (HLLs) for Field-Programmable Gate Arrays (FPGAs) facilitate the use of reconfigurable computing resources for application developers by using familiar, higher-level syntax, semantics, and abstractions, typically enabling faster development times than with traditional Hardware Description Languages (HDLs). However, programming at a higher level of abstraction is typically accompanied by some loss of performance as well as reduced transparency of application behavior, making it difficult to understand and improve application performance. While runtime tools for performance analysis are often featured in development with traditional HLLs for sequential and parallel programming, HLL-based development for FPGAs has an equal or greater need yet lacks these tools. This article presents a novel and portable framework for runtime performance analysis of HLL applications for FPGAs, including an automated tool for performance analysis of designs created with Impulse C, a commercial HLL for FPGAs. As a case study, this tool is used to successfully locate performance bottlenecks in a molecular dynamics kernel in order to gain speedup.

A semantic-mediation architecture for interoperable supply-chain applications

This paper presents a semantic-mediation architecture that enables standards-based interoperability between heterogeneous supply-chain applications. The architecture was implemented using a state-of-the-art semantic-mediation toolset for design-time and run-time integration tasks. The design-time tools supported a domain ontology definition, message annotations, message schema transformations and reconciliation rules specifications. The run-time tools performed exchanges, transformations, and reconciliations of the messages. The architecture supports a supply-chain integration scenario where heterogeneous automotive manufacturing supply-chain applications exchange inventory information.

Open graphical framework for interactive TV

Multimedia end-user terminals are expected to perform advanced user interface related tasks. These tasks are carried out by user interface runtime tools and include, among others, the visualization of complex graphics and the efficient handling of user input. In addition, the terminal's graphical system is expected, for example, to be able to synchronize audio and video, and control different contexts on the same screen. Finally, the availability of high-level tools to simplify the user interface implementation and the adaptiveness of the user interfaces for a diversity of configurations are, as well, desirable features. This paper presents a layered model that meets the just mentioned requirements. The architecture is divided into five different layers: hardware abstraction layer, multimedia cross platform libraries, graphical environment, GUI toolkit and high-level languages. Moreover, this paper presents the experiences of developing a prototype system based on the architecture, targeted to digital television receivers. In order to evaluate the prototype, some already developed DVB-MHP compliant digital television applications were tested. Finally, the prototype was extended with a high-level profile (i.e., SMIL support) and a low-level one (i.e., access to the framebuffer memory).

Consistency analysis of authorization hook placement in the Linux security modules framework

We present a consistency analysis approach to assist the Linux community in verifying the correctness of authorization hook placement in the Linux Security Modules (LSM) framework. The LSM framework consists of a set of authorization hooks inserted into the Linux kernel to enable additional authorizations to be performed (e.g., for mandatory access control). When compared to system call interposition, authorization within the kernel has both security and performance advantages, but it is more difficult to verify that placement of the LSM hooks ensures that all the kernel's security-sensitive operations are authorized. Static analysis has been used previously to verified mediation (i.e., that some hook mediates access to a security-sensitive operation), but that work did not determine whether the necessary set of authorizations were checked. In this paper, we develop an approach to test the consistency of the relationships between security-sensitive operations and LSM hooks. The idea is that whenever a security-sensitive operation is performed as part of specifiable event, a particular set of LSM hooks must have mediated that operation. This work demonstrates that the number of events that impact consistency is manageable and that the notion of consistency is useful for verifying correctness. We describe our consistency approach for performing verification, the implementation of run-time tools that implement this approach, the anomalous situations found in an LSM-patched Linux 2.4.16 kernel, and an implementation of a static analysis version of this approach.

An extensible program representation for object-oriented software

An extensible representation for object-oriented programs is presented. It is based on the concept of a program dependency graph and elaborated to include both control flow and data flow information. The representation takes advantage of the basic incremental philosophy of the object-oriented approach to develop a more compact representation that is useful with practical programs. The basic approach reported here provides a static view of an object-oriented program. The approach can be expanded to provide dynamic information for tools such as interactive debuggers and other runtime tools. The outline of this extension is also presented.

A survey of run-time and logic errors in a classroom environment

This paper presents the results of a survey of programming errors in an introductory programming class conducted at Kansas State University. The objective of the study was to gain a better understanding of some of the errors made by beginning student programmers, particularly those effors normally detected by run-time packages (e.g., undefined variables, division by zero, arithmethic overflow) as well as the many effors that pass undetected by compilers and run-time tools (e.g., logic and conceptual effors). The survey involved the analysis of 1088 program runs collected from approximately 50 students in a FORTRAN programming course.The effors were tallied and analyzed, and were then recorded under eight general categories: Input/Output (e. g., missing I/O statements, missing or incorrect I/O variables or data); Assignment (e. g., incorrect operators, missing assignments); Loops (e. g., incorrect loop parameters, missing or extra loops); Decision and Branching (e. g., jump to wrong places, incorrect decisions; Arrays (e. g., incorrect subscripts, missing array); Subprograms (e. g., incorrect or missing parameters, incorrect number of calls); Declarations (e. g., issing or wrong declaration statements, wrong names in declaration statements); and Miscellaneous (e. g., unused variables, redundant decisions, wrong logic). The study found that two classes of errors accounted for over half of all noncompiletime errors: those errors related to input/output and assignment statements. Further analysis showed that less than half of the run-time error messages generated by the compiler actually pinpointed the cause of error or provided a meaningful hint.