AI: a lightweight system for tolerating concurrency bugs

@article{Zhang2014AIAL,
  title={AI: a lightweight system for tolerating concurrency bugs},
  author={Mingxing Zhang and Yongwei Wu and Shan Lu and Shanxiang Qi and Jinglei Ren and Weimin Zheng},
  journal={Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering},
  year={2014}
}
  • Mingxing Zhang, Yongwei Wu, Weimin Zheng
  • Published 11 November 2014
  • Computer Science
  • Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering
Concurrency bugs are notoriously difficult to eradicate during software testing because of their non-deterministic nature. Moreover, fixing concurrency bugs is time-consuming and error-prone. Thus, tolerating concurrency bugs during production runs is an attractive complementary approach to bug detection and testing. Unfortunately, existing bug-tolerating tools are usually either 1) constrained in types of bugs they can handle or 2) requiring roll-back mechanism, which can hitherto not be fully… 
A Lightweight System for Detecting and Tolerating Concurrency Bugs
TLDR
A novel program invariant, name Anticipating Invariant (<sc>Ai</sc), that can detect most types of concurrency bugs and can be used to anticipate many concurrency Bugs before any irreversible changes have been made is presented.
Applying Hardware Transactional Memory for Concurrency-Bug Failure Recovery in Production Runs
TLDR
The proposed BugTM greatly improves the recovery capability of state-of-the-art techniques with low run-time overhead and no changes to OS or hardware, while guarantees not to introduce new bugs.
Applying Transactional Memory for Concurrency-Bug Failure Recovery in Production Runs
TLDR
This paper proposes BugTM, an approach that applies transactional memory techniques for concurrency-bug recovery in production runs with low run-time overhead and no changes to OS or hardware, while guarantees not to introduce new bugs.
A comprehensive study on real world concurrency bugs in Node.js
  • Jie Wang, Wensheng Dou, Jun Wei
  • Computer Science
    2017 32nd IEEE/ACM International Conference on Automated Software Engineering (ASE)
  • 2017
TLDR
This paper presents NodeCB, a comprehensive study on real world concurrency bugs in Node.js, and obtains several interesting findings, which may open up many new research directions in combating concurrency Bugs inNode.js.
Supervised testing of concurrent software in embedded systems
TLDR
The approach uses virtual prototyping to enable design space exploration of systems with complex scheduling schemes by investigating the influence of the scheduling scheme on the synchronization of concurrent software.
Fixing, preventing, and recovering from concurrency bugs
TLDR
Recent progresses on fixing, preventing, and recovering from concurrency bugs are discussed.
Testing multithreaded programs via thread speed control
TLDR
The design, implementation, and evaluation of the new concept of speed space in which each vector denotes a family of thread schedules for exploring adversarial/abnormal schedules are discussed and the experimental results confirm that the technique is effective in sampling diverse schedules.
Repairing Event Race Errors by Controlling Nondeterminism
TLDR
The results show that application-independent repair policies usually suffice to repair event race errors without excessive negative impact on performance or user experience, though application-specific repair policies that target specific event races are sometimes desirable.
Concurrency Bug Avoiding Based on Optimized Software Transactional Memory
TLDR
Experimental results show that Convoider succeeds in transparently transactionalizing twelve real-world applications with averagely incurring only 28% runtime overhead and perfectly avoid 94% of concurrency bugs used in the experiments.
...
1
2
...

References

SHOWING 1-10 OF 39 REFERENCES
ConAir: featherweight concurrency bug recovery via single-threaded idempotent execution
TLDR
Quantitatively, ConAir helps software survive failures caused by all of these bugs with negligible run-time overhead (<1%) and short recovery time and guarantees that program semantics remain unchanged and requires no change to operating systems or hardware.
ConMem: detecting severe concurrency bugs through an effect-oriented approach
TLDR
This paper built ConMem to monitor program execution, analyze memory accesses and synchronizations, and predicatively detect common and severe concurrency-memory bugs, and built a validator ConMem-v to automatically prune false positives by enforcing potential bug-triggering interleavings.
Applying transactional memory to concurrency bugs
TLDR
Four methods of using TM on three concurrent programs are investigated, and it is found that 29% of the bugs are not fixable by transactional memory, showing that TM does not address many important types of concurrency bugs.
Do I use the wrong definition?: DeFuse: definition-use invariants for detecting concurrency and sequential bugs
TLDR
An invariant-based bug detection tool, DefUse, which can detect not only concurrency bugs (including the previously under-studied order violation bugs), but also memory and semantic bugs, and an algorithm to automatically extract such invariants from programs, which are then used to detect bugs.
CTrigger: exposing atomicity violation bugs from their hiding places
TLDR
CTrigger focuses on a special type of interleavings that are inherently correlated to atomicity violation bugs, and uses trace analysis to systematically identify (likely) feasible unserializable interleAVings with low occurrence-probability that are exposed in large programs.
Multicore acceleration of priority-based schedulers for concurrency bug detection
TLDR
NeedlePoint is described, an open-source framework that allows selection and comparison of a wide range of interleaving exploration policies for bug detection proposed by prior work and it is formally prove that parallel PCT provides the same probabilistic coverage guarantees as PCT.
Instrumentation and sampling strategies for cooperative concurrency bug isolation
TLDR
This work presents Cooperative Crug Isolation (CCI), a low-overhead instrumentation framework to diagnose production-run failures caused by crugs, and offers a varied suite of predicates that represent different trade-offs between complexity and fault isolation capability.
A randomized scheduler with probabilistic guarantees of finding bugs
TLDR
It is hypothesized that in practice, many concurrency bugs have small bug-depths, and the efficiency of the schedule randomization is confirmed by detecting previously unknown and known concurrency Bugs in several production-scale concurrent programs.
A randomized scheduler with probabilistic guarantees of finding bugs
TLDR
It is hypothesized that in practice, many concurrency bugs have small bug-depths, and the efficiency of the schedule randomization is confirmed by detecting previously unknown and known concurrency Bugs in several production-scale concurrent programs.
Finding concurrency bugs with context-aware communication graphs
  • Brandon Lucia, L. Ceze
  • Computer Science
    2009 42nd Annual IEEE/ACM International Symposium on Microarchitecture (MICRO)
  • 2009
TLDR
This paper proposes context-aware communication graphs, a new kind of communication graph that encodes global ordering information by embedding communication contexts and builds Bugaboo, a simple and generic framework that accurately detects complex concurrency bugs.
...
1
2
3
4
...