CARE: cache guided deterministic replay for concurrent Java programs

Jiang, Yanyan; Gu, Tianxiao; Xu, Chang; Ma, Xiaoxing; Lü, Jian

doi:10.1145/2568225.2568236

Cited by 21 publications

(13 citation statements)

References 44 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…If the current node satisfies the second condition, it is inserted into the previous position of tei nearest , and the current two nodes are merged into a new node (lines [12][13][14][15]). If the current node satisfies the third condition and is closer to tei nearest , it is inserted into the previous position of tei nearest , and the current two nodes are merged into a new node (lines [16][17][18][19][20][21][22][23]. If the current node satisfies the third condition and is closer to tei deped_n , it is inserted into the previous position of tei deped_n (lines 24-26).…”

Section: Backward Refactoring the Context Switch Linked Listmentioning

confidence: 99%

“…The reasons are that: (1) multiple threads can access shared memory without any restrictions in concurrent programs, which easily leads to a variety of potential concurrency bugs; (2) concurrency bugs only occur for specific input and thread scheduling, making them difficult to reproduce; and (3) concurrency bugs are difficult to diagnose, and frequent context switches hinder developers from understanding the concurrent program execution trace.Previous studies have proposed many approaches to expose and to detect varieties of concurrency bugs, such as deadlocks, 2,3 data races, 4-9 atomicity violations, 10-12 and order violations. [13][14][15] Besides, a rich body of deterministic record and replay techniques [16][17][18] have been developed to replay concurrency bugs effectively and efficiently. However, few approaches attempt to reason about concurrency bugs.…”

mentioning

confidence: 99%

See 1 more Smart Citation

A bidirectional trace simplification approach based on a context switch linked list for concurrent programs

Jiang

Wang

et al. 2019

Concurrency and Computation

View full text Add to dashboard Cite

Summary Concurrent programs are notoriously difficult to debug due to shared memory and the non‐determined nature of thread scheduling. Frequent context switches add a huge burden on developers in reasoning about concurrency bugs. To alleviate this problem, we present a bidirectional trace simplification approach based on a context switch linked list. First, we calculate the dependence relations, including local dependences, synchronization dependences, and remote read/write dependences. Second, we construct a context switch linked list according to the original buggy trace. Then, we backward refactor the context switch linked list in sequence to extend thread execution intervals. Finally, we forward check the context switch linked list in sequence to ensure that no nodes can be further merged. We have conducted experiments on eight Java multi‐threaded programs to evaluate our approach. The results show that our approach performs better than or is comparable to the compared static approaches in effectiveness and efficiency.

show abstract

Section: Backward Refactoring the Context Switch Linked Listmentioning

confidence: 99%

mentioning

confidence: 99%

A bidirectional trace simplification approach based on a context switch linked list for concurrent programs

Jiang

Wang

et al. 2019

Concurrency and Computation

View full text Add to dashboard Cite

show abstract

“…Regarding software-based systems, they can be broadly classified as order-based or search-based. LEAP, [6] Order, [18] and CARE [19] are state-of-the-art order-based solutions that record the exact read-write linkage of shared-memory accesses. They essentially vary in the technique used to minimize contention when recording the order of events: LEAP tracks shared accesses on a per-variable basis, Order traces thread interleavings at the object instance level, and CARE exploits thread local caches to identify the subset of all exact read-write linkages that have to be recorded.…”

Section: Related Workmentioning

confidence: 99%

CoopREP: Cooperative record and replay of concurrency bugs

Machado

Romano

Rodrigues

2017

Software Testing Verif & Rel

View full text Add to dashboard Cite

SummaryThis paper presents CoopREP, a system that provides support for fault replication of concurrent programs based on cooperative recording and partial log combination. CoopREP uses partial logging to reduce the amount of information that a given program instance is required to store to support deterministic replay. This allows reducing substantially the overhead imposed by the instrumentation of the code, but raises the problem of finding a combination of logs capable of replaying the fault. CoopREP tackles this issue by introducing several innovative statistical analysis techniques aimed at guiding the search of the partial logs to be combined and needed for the replay phase. CoopREP has been evaluated using both standard benchmarks for multithreaded applications and real-world applications. The results highlight that CoopREP can successfully replay concurrency bugs involving tens of thousands of memory accesses, while reducing recording overhead with respect to state-of-the-art noncooperative logging schemes by up to 13× (and by 2.4× on average). KEYWORDSconcurrency errors, debugging, partial logging, record and replay INTRODUCTIONConcurrent programming is of paramount importance to exploit the full potential of the emerging multicore architectures. However, writing and debugging concurrent programs is notoriously difficult. Contrary to most bugs in sequential programs, which usually depend exclusively on the program input and the execution environment (and, therefore, can be more easily reproduced), concurrency bugs depend on nondeterministic interactions among threads. This means that even when re-executing the same code with identical inputs, on the same machine, the outcome of the program may differ from run to run [1].Deterministic replay (or record and replay) addresses this issue by recording nondeterministic events (such as the order of access to shared-memory locations) during a failing execution and, then, use the resulting trace to support the reproduction of the error [2]. Classic approaches, [3-6] also referred to as order-based, trace the relative order of all relevant events, thus allowing to replay the bug at the first attempt. Unfortunately, they also come with an excessively high recording cost (10×-100× slowdown), which is impractical for most settings.Motivated by the observation that the most significant performance constraints are on production runs, more recent solutions have adopted a search-based approach [1,7-9]. Search-based solutions reduce the recording overhead at the cost of a longer reproduction time during diagnosis.To this end, they typically log incomplete information at runtime and rely on post-recording exploration techniques to complete the missing data.These techniques explore various trade-offs between recording overhead and replay efficacy (ie, number of replay attempts required to reproduce the bug).The work in this paper aims at further reducing the overhead achievable using either order-based or search-based techniques, by devising cooperative logging schemes tha...

show abstract

“…Consequently, if a concurrency bug manifests in the field, the ability to reproduce the bug on the same input can be extremely challenging. This has lead to the design of a number of concurrency bug detection [47,37] and reproduction approaches [16,19]. Also, there has been a significant effort in reducing (or eliminating) the non-determinism by restricting the feasible schedule(s) for a given input.…”

Section: Introductionmentioning

confidence: 99%

Pegasus: automatic barrier inference for stable multithreaded systems

Dhok

Mudduluru

Ramanathan

2015

Proceedings of the 2015 International Symposium on Software Testing and Analysis

View full text Add to dashboard Cite

Deterministic multithreaded systems (DMTs) are designed to ensure reproducibility of program behavior for a given input. In these systems, even minor changes to the code (or input) can perturb the schedule. This increases the number of feasible schedules making reasoning about these programs harder. Stable multithreaded systems (StableMTs) address the problem such that a schedule is unaffected by minor changes. Unfortunately, determinism in these systems can potentially serialize the execution imposing a significant penalty on the performance. Programmer hints in the form of soft barriers attempt to eliminate the performance bottlenecks. However, the process is arduous, error-prone and requires manual intervention to reconsider the location of the barrier for every modification to the source code.In this paper, we propose an effective approach to automate the task of adding soft barriers in the source code. Our approach analyzes the deterministic program executions to extract the program and semantic order of executions and builds a weighted constraint graph. Using this graph, a schedule is synthesized which is used to identify bottlenecks and insert soft barriers in the program source.We validate our implementation, named PEGASUS, by applying it on multiple benchmarks. Our experimental results demonstrate that we are able to reduce the overall execution time of programs by upto 34% when compared to the execution time where barriers are inserted manually. Moreover, we observe a performance improvement ranging from 38% to 88% as compared to programs without barriers. Our experimental results show that adapting PEGASUS to infer barriers for multiple versions of a source program is seamless. The memory and time overheads associated with the usage of PEGASUS is negligible making it a vital cog in building scalable StableMTs.

show abstract

CARE: cache guided deterministic replay for concurrent Java programs

Cited by 21 publications

References 44 publications

A bidirectional trace simplification approach based on a context switch linked list for concurrent programs

A bidirectional trace simplification approach based on a context switch linked list for concurrent programs

CoopREP: Cooperative record and replay of concurrency bugs

Pegasus: automatic barrier inference for stable multithreaded systems

Contact Info

Product

Resources

About