Ok-Kyoon Ha

On-the-fly detection of data races in OpenMP programs

OpenMP provides a portable way to achieve high performance and simple compiler directives to transform a sequential program into parallel program. It is important to detect data races in OpenMP programs, because they may lead to unpredictable results from an execution of the programs. To detect data races that occur during an execution of OpenMP programs, the representative on-the-fly technique, Helgrind+, mainly focuses on reducing false positives. Unfortunately, this technique is still imprecise and inefficient, when applied to large OpenMP programs which use a structured fork-join parallelism with a large number of threads. This paper presents a novel approach which efficiently detects apparent data races without false positives in large OpenMP programs. This approach combines an efficient thread labeling to maintain the logical concurrency of thread segments with a precise detection protocol to analyze conflicting accesses to every shared memory location. We implemented this approach on top of the Pin binary instrumentation framework and compared it with Helgrind+. Empirical results using OpenMP benchmarks show that our technique detects apparent data races without false positives contrarily to Helgrind+, while reducing the average runtime overhead to 19% of Helgrind+ with a similar amount of space overhead.

On-the-fly healing of race conditions in ARINC-653 flight software

The ARINC-653 standard architecture for flight software specifies an application executive (APEX) which provides an application programming interface and defines a hierarchical framework which provides health management for error detection and recovery. In every partition of the architecture, however, asynchronously concurrent processes or threads may include concurrency bugs such as unintended race conditions which are common and difficult to remove by testing. A race condition toward a shared data, or data race, is a pair of unsynchronized instructions that access a shared variable with at least one write access. Data races threaten the reliability of shared-memory programs seriously and latently, because they result in unintended nondeterministic executions of the programs. To heal data race during executions of ARINC-653 flight software, this paper instruments on-the-fly race detection into the target program and incorporates on-the-fly race healing into the health management of the ARINC-653 architecture. The race detection signals to the health monitor using the corresponding APEX call, if a data race is detected. The health monitor then responds by invoking an aperiodic, user-defined, error handling process that is assigned the highest possible priority. This special process uses an APEX call to identify and then heals the occurrence of race condition as an application error, one of seven error types defined by ARINC-653. This race-healing process allows the target programs to be assured at run-time that the execution result of the healed program could have been in the original program and therefore no new functional bug has been introduced. This paper evaluates efficiencies of the on-the-fly mechanisms to argue that they are practical to be configured under the ARINC-653 partitions.

An efficient algorithm for on-the-fly data race detection using an epoch-based technique

Data races represent the most notorious class of concurrency bugs in multithreaded programs. To detect data races precisely and efficiently during the execution of multithreaded programs, the epoch-based FastTrack technique has been employed. However, FastTrack has time and space complexities that depend on the maximum parallelism of the program to partially maintain expensive data structures, such as vector clocks. This paper presents an efficient algorithm, called iFT, that uses only the epochs of the access histories. Unlike FastTrack, our algorithm requires O(1) operations to maintain an access history and locate data races, without any switching between epochs and vector clocks. We implement this algorithm on top of the Pin binary instrumentation framework and compare it with other on-the-fly detection algorithms, including FastTrack, which uses a state-of-the-art happens-before analysis algorithm. Empirical results using the PARSEC benchmark show that iFT reduces the average runtime and memory overhead to 84% and 37%, respectively, of those of FastTrack.

Lightweight Labeling Scheme for On-the-fly Race Detection of Signal Handlers

Data races represent one of the most notorious class of bugs in shared-memory parallel programs since they are hard to reproduce and can lead programs into unintended nondeterministic executions. However, data races can also show up in sequential programs that use signals when a signal handler and the sequential program both access without proper synchronization, a shared variable with at least one write-access operation. Unfortunately, existing tools for race detection in such programs produce high time and space overhead that drastically slow down the monitored program. This overhead is partly due to the use of costly and inappropriate timestamps originally designed for threads’ ordering in multithreaded programs. This paper presents a lightweight labeling scheme for efficient on-the-fly race detection in sequential programs that use signal handlers. This scheme generates constant-sized labels for the program and its signal handlers and determines the logical concurrency between instructions accessing the same shared memory. Generating and comparing concurrency information are done in constant time. The efficiency of the technique and its limited footprint on the program execution make the on-the-fly race detection more practical in sequential programs.

Dynamic instrumentation for nested fork-join parallelism in OpenMP programs

It is important to determine the logical concurrency of OpenMP programs, because it helps detecting data races between two threads in an execution of the program. RaceStand have been developed to detect on-the-fly data races for OpenMP applications. Unfortunately, the previous tool does not detect data races or reports false positives for nested fork-join parallelism which uses function calls for the execution of parallel regions by its defective source code instrumentation. In this paper, we present an instrumentor to determine logical concurrency of parallel threads using a dynamic binary instrumentation technique based on Pin software framework. We implemented a Pin-tool as data race detection tool including our instrumentor, and empirically compared the correctness of the Pin-tool with previous tool using a set of synthetic programs considering nested parallelism and function calls.

Efficient Thread Labeling for On-the-fly Race Detection of Programs with Nested Parallelism

On-the-fly race detector using Lamport’s happened-before relation needs thread labeling scheme for generating unique identifiers which maintain logical concurrency information for the parallel thread. e-NR labeling creates the NR labels by inheriting from the parent thread a pointer to their shared information, so it requires constant amount of time and space overhead on every fork/join operation. Previous work compares e-NR labeling only with OS labeling using a set of synthetic programs to support that e-NR labeling is efficient in detecting races during an execution of programs with nested parallelism. This paper compares empirically e-NR labeling with BD labeling that shows the same complexity of space and time with OS labeling. The results using OpenMP benchmarks with nested parallelism show that e-NR labeling is more efficient than T-BD labeling by at least 2 times in total monitoring time for race detection, and by at least 3 times in average space for maintaining thread labels.

A Tool for Detecting First Races in OpenMP Programs

First race detection is especially important for effective debugging, because the removal of such races may make other affected races disappear. The previous tools can not guarantee that detected races are the first races to occur. We present a new tool to detect first races in a program with nested parallelism using a two-pass on-the-fly technique. To show accuracy, we empirically compare our tool with previous tools using a set of synthetic programs with OpenMP directives.

Light-Weight and Versatile Monitor for a Self-Adaptive Software Framework for IoT Systems

Today, various Internet of Things (IoT) devices and applications are being developed. Such IoT devices have different hardware (HW) and software (SW) capabilities; therefore, most applications require customization when IoT devices are changed or new applications are created. However, the applications executed on these devices are not optimized for power and performance because IoT device systems do not provide suitable static and dynamic information about fast-changing system resources and applications. Therefore, this paper proposes a light-weight and versatile monitor for a self-adaptive software framework to automatically control system resources according to the system status. The monitor helps running applications guarantee low power consumption and high performance for an optimal environment. The proposed monitor has two components: a monitoring component, which provides real-time static and dynamic information about system resources and applications, and a controlling component, which supports real-time control of system resources. For the experimental verification, we created a video transport system based on IoT devices and measured the CPU utilization by dynamic voltage and frequency scaling (DVFS) for the monitor. The results demonstrate that, for up to 50 monitored processes, the monitor shows an average CPU utilization of approximately 4% in the three DVFS modes and demonstrates maximum optimization in the Performance mode of DVFS.

Visualizing concurrency faults in ARINC-653 real-time applications

The ARINC-653 standard architecture for flight software specifies an application executive (APEX) which provides an application programming interface and defines a hierarchical framework which provides health management for error detection and recovery. In every partition of the architecture, however, processes may have to deal with asynchronous realtime signals from peripheral devices or may communicate with other processes through blackboards or buffers. This configuration may lead programs into concurrency faults such as unintended race conditions which are common and difficult to be removed by testing. Unfortunately, existing tools for reporting concurrency faults in applications that use concurrent signal handlers can neither represent the complex interactions between an ARINC-653 application and its error handlers nor provide effective means for understanding the dynamic behavior of concurrent signal handlers involved into data races. Thus, this paper presents an intuitive tool that visualizes the partial ordering of runtime events to detect concurrency faults in an ARINC-653 application that uses concurrent signal handlers. It uses vertically parallel arrows with different colors to capture the logical concurrency between the application, its error handlers and concurrent signal handlers, and materializes synchronization operations with differently colored horizontal arrows. Our visualization tool allows at a glance, to visually detect data races and provides a great understanding of the program internal for an easy debugging process.

Efficient race verification for debugging programs with openMP directives

Races must be detected for debugging parallel programs with OpenMP directives because they may cause unintended nondeterministic results of programs. The previous tool that detects races does not verify the existence of races in programs with no internal nondeterminism because the tool regards nested sibling threads as ordered threads and has the possibility of ignoring accesses involved in races in program models with synchronization such as critical section. This paper suggests an efficient tool that verifies the existence of races with optimal performance by applying race detection engines for labeling and detection protocol. The labeling scheme generates a unique identifier for each parallel thread created during a program execution, and the protocol scheme detects at least one race if any. This tool verifies the existence of races over 250 times faster in average than the previous tool even in the case that the maximum parallelism increases with the fixed number of total accesses using a set of synthetic programs without synchronization such as critical section.