NDLI: Do I use the wrong definition?: DeFuse: definition-use invariants for detecting concurrency and sequential bugs

Please wait, while we are loading the content...

The case for evolvable software

Efficient modular glass box software model checking

A domain-specific approach to architecturing error handling in pervasive computing

Lime: a Java-compatible and synthesizable language for heterogeneous architectures

Composable specifications for structured shared-memory communication

A study of Java's non-Java memory

Instrumentation and sampling strategies for cooperative concurrency bug isolation

Specifying and implementing refactorings

Type classes as objects and implicits

Symbolic heap abstraction with demand-driven axiomatization of memory invariants

The spoofax language workbench: rules for declarative specification of languages and IDEs

Reasoning about multiple related abstractions with MultiStar

Random testing for higher-order, stateful programs

Ownership and immutability in generic Java

Automatic atomic region identification in shared memory SPMD programs

SPUR: a trace-based JIT compiler for CIL

Registration-based language abstractions

Patterns and statistical analysis for understanding reduced resource computing

Flexible modeling tools for pre-requirements analysis: conceptual architecture and research challenges

Better science through art

Art, science, and fear

An experiment about static and dynamic type systems: doubts about the positive impact of static type systems on development time

G-Finder: routing programming questions closer to the experts

From OO to FPGA: fitting round objects into square hardware?

Do I use the wrong definition?: DeFuse: definition-use invariants for detecting concurrency and sequential bugs

Hera-JVM: a runtime system for heterogeneous multi-core architectures

What can the GC compute efficiently?: a language for heap assertions at GC time

A graph-based approach to API usage adaptation

Supporting dynamic, third-party code customizations in JavaScript using aspects

A dynamic evaluation of the precision of static heap abstractions

MetaFJig: a meta-circular composition language for Java-like classes

Homogeneous family sharing

The two-state solution: native and serializable continuations accord

Tribal ownership

Task types for pervasive atomicity

Refactoring references for library migration

Pinocchio: bringing reflection to life with first-class interpreters

Programming with time: cyber-physical programming with impromptu

To upgrade or not to upgrade: impact of online upgrades across multiple administrative domains

Rubber ducks, nightmares, and unsaturated predicates: proto-scientific schemata are good for agile

To achieve our highest goals, we must be willing to abandon them

A simple inductive synthesis methodology and its applications

Agility in context

An input-centric paradigm for program dynamic optimizations

Scalable and systematic detection of buggy inconsistencies in source code

Cross-language, type-safe, and transparent object sharing for co-located managed runtimes

Monitor optimization via stutter-equivalent loop transformation

Component adaptation and assembly using interface relations

Dynamic parallelization of recursive code: part 1: managing control flow interactions with the continuator

Parallel inclusion-based points-to analysis

Modular logic metaprogramming

Mostly modular compilation of crosscutting concerns by contextual predicate dispatch

Back to the futures: incremental parallelization of existing sequential runtime systems

A time-aware type system for data-race protection and guaranteed initialization

Concurrent programming with revisions and isolation types

Performance analysis of idle programs

Concurrency by modularity: design patterns, a case in point

Language virtualization for heterogeneous parallel computing

Managing ambiguity in programming by finding unambiguous examples

Pure and declarative syntax definition: paradise lost and regained

F#: Taking Succinct, Efficient, Typed Functional Programming into the Mainstream

Faith, hope, and love: an essay on software science's neglect of human factors

The Tower of Babel did not fail

Do I use the wrong definition?: DeFuse: definition-use invariants for detecting concurrency and sequential bugs

Content Provider	ACM Digital Library
Author	Shi, Yao Zhou, Yuanyuan Lu, Shan Yin, Zuoning Park, Soyeon Zheng, Weimin Chen, Wenguang
Abstract	Software bugs, such as concurrency, memory and semantic bugs, can significantly affect system reliability. Although much effort has been made to address this problem, there are still many bugs that cannot be detected, especially concurrency bugs due to the complexity of concurrent programs. Effective approaches for detecting these common bugs are therefore highly desired. This paper presents 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. Based on the observation that many bugs appear as violations to programmers' data flow intentions, we introduce three different types of definition-use invariants that commonly exist in both sequential and concurrent programs. We also design an algorithm to automatically extract such invariants from programs, which are then used to detect bugs. Moreover, DefUse uses various techniques to prune false positives and rank error reports. We evaluated DefUse using sixteen real-world applications with twenty real-world concurrency and sequential bugs. Our results show that DefUse can effectively detect 19 of these bugs, including 2 new bugs that were never reported before, with only a few false positives. Our training sensitivity results show that, with the benefit of the pruning and ranking algorithms, DefUse is accurate even with insufficient training.
Starting Page	160
Ending Page	174
Page Count	15
File Format	PDF
ISBN	9781450302036
DOI	10.1145/1869459.1869474
Language	English
Publisher	Association for Computing Machinery (ACM)
Publisher Date	2010-10-17
Publisher Place	New York
Access Restriction	Subscribed
Subject Keyword	Concurrency bug Atomicity violation Order violation Sequential bug
Content Type	Text
Resource Type	Article

Central Library (ISO-9001:2015 Certified)
Indian Institute of Technology Kharagpur
Kharagpur, West Bengal, India | PIN - 721302

See location in the Map
03222 282435
Mail: support@ndl.gov.in

Sl.	Authority	Responsibilities	Communication Details
1	Ministry of Education (GoI), Department of Higher Education	Sanctioning Authority	https://www.education.gov.in/ict-initiatives
2	Indian Institute of Technology Kharagpur	Host Institute of the Project: The host institute of the project is responsible for providing infrastructure support and hosting the project	https://www.iitkgp.ac.in
3	National Digital Library of India Office, Indian Institute of Technology Kharagpur	The administrative and infrastructural headquarters of the project	Dr. B. Sutradhar bsutra@ndl.gov.in
4	Project PI / Joint PI	Principal Investigator and Joint Principal Investigators of the project	Dr. B. Sutradhar bsutra@ndl.gov.in Prof. Saswat Chakrabarti will be added soon
5	Website/Portal (Helpdesk)	Queries regarding NDLI and its services	support@ndl.gov.in
6	Contents and Copyright Issues	Queries related to content curation and copyright issues	content@ndl.gov.in
7	National Digital Library of India Club (NDLI Club)	Queries related to NDLI Club formation, support, user awareness program, seminar/symposium, collaboration, social media, promotion, and outreach	clubsupport@ndl.gov.in
8	Digital Preservation Centre (DPC)	Assistance with digitizing and archiving copyright-free printed books	dpc@ndl.gov.in
9	IDR Setup or Support	Queries related to establishment and support of Institutional Digital Repository (IDR) and IDR workshops	idr@ndl.gov.in