A comprehensive study on real world concurrency bugs in Node.js

Wang, Jie; Dou, Wensheng; Gao, Yu; Gao, Chushu; Qin, Feng; Kang, Y. James; Wei, Jun

doi:10.1109/ase.2017.8115663

Cited by 43 publications

(25 citation statements)

References 32 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Wang et al [4] present a study on 57 concurrency bugs in 53 Node.js applications (about 3.5M LOC). The paper proposes several different analyses pertaining to the retrieved bugs, such as bug patterns, root causes, and repair strategies.…”

Section: A Bug-related Studies For Javascriptmentioning

confidence: 99%

“…Despite its popularity, the intrinsic characteristics of JavaScript-such as weak typing, prototypal inheritance, and run-time evaluation-make it one of the most error-prone programming languages. As such, a large body of software engineering research has focused on the analysis and testing of JavaScript web applications [2,3,4,5,6,7,8,9].…”

Section: Introductionmentioning

confidence: 99%

“…In the JavaScript domain, the term benchmark commonly refers to collections of programs used to measure and test the performance of web browsers with respect to the latest JavaScript features and engines. Instances of such performance benchmarks are JetStream, 4 Kraken, 5 Dromaeo, 6 Octane, 7 and V8. 8 In this work, however, we refer to benchmark as a collection of JavaScript programs and artifacts (e.g., test cases or bug reports) used to support empirical studies (e.g., controlled experiments or user studies) related to one or more research areas in software analysis and testing.…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

BugsJS: a Benchmark of JavaScript Bugs

Gyimesi

Vancsics

Stocco

et al. 2019

2019 12th IEEE Conference on Software Testing, Validation and Verification (ICST)

View full text Add to dashboard Cite

JavaScript is a popular programming language that is also error-prone due to its asynchronous, dynamic, and loosely-typed nature. In recent years, numerous techniques have been proposed for analyzing and testing JavaScript applications. However, our survey of the literature in this area revealed that the proposed techniques are often evaluated on different datasets of programs and bugs. The lack of a commonly used benchmark limits the ability to perform fair and unbiased comparisons for assessing the efficacy of new techniques. To fill this gap, we propose BUGSJS, a benchmark of 453 real, manually validated JavaScript bugs from 10 popular JavaScript server-side programs, comprising 444k LOC in total. Each bug is accompanied by its bug report, the test cases that detect it, as well as the patch that fixes it. BUGSJS features a rich interface for accessing the faulty and fixed versions of the programs and executing the corresponding test cases, which facilitates conducting highly-reproducible empirical studies and comparisons of JavaScript analysis and testing tools.

show abstract

Section: A Bug-related Studies For Javascriptmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

BugsJS: a Benchmark of JavaScript Bugs

Gyimesi

Vancsics

Stocco

et al. 2019

2019 12th IEEE Conference on Software Testing, Validation and Verification (ICST)

View full text Add to dashboard Cite

show abstract

“…Atomicity allows programmers to reason about atomic blocks without worrying about the effects of other threads. Unfortunately, violation of atomicity specifications is quite common and is the root cause in a majority of real-world bugs [9,13,22,29,35,37,61].…”

Section: Introductionmentioning

confidence: 99%

Atomicity Checking in Linear Time using Vector Clocks

Mathur

Viswanathan

2020

Proceedings of the Twenty-Fifth International Conference on Architectural Support for Programming Languages and Operating Syste

View full text Add to dashboard Cite

Multi-threaded programs are challenging to write. Developers often need to reason about a prohibitively large number of thread interleavings to reason about the behavior of software. A non-interference property like atomicity can reduce this interleaving space by ensuring that any execution is equivalent to an execution where all atomic blocks are executed serially. We consider the well studied notion of conflict serializability for dynamically checking atomicity. Existing algorithms detect violations of conflict serializability by detecting cycles in a graph of transactions observed in a given execution. The number of edges in such a graph can grow quadratically with the length of the trace making the analysis not scalable. In this paper, we present AeroDrome, a novel single pass linear time algorithm that uses vector clocks to detect violations of conflict serializability in an online setting. Experiments show that AeroDrome scales to traces with a large number of events with significant speedup. CCS Concepts. • Software and its engineering → Dynamic analysis; Software testing and debugging.

show abstract

“…e currently ubiquitous multicore architecture necessitates concurrent programming, especially multithreaded programming [1][2][3]. Unfortunately, writing concurrent programs is challenging: multithreaded programs often suffer from concurrency bugs such as deadlocks, data races, atomicity violations, and order violations [4], which are notoriously difficult to expose [5,6], detect [6][7][8], debug [8], and repair [9,10] because of their nondeterminism nature.…”

Section: Introductionmentioning

confidence: 99%

Concurrency Bug Avoiding Based on Optimized Software Transactional Memory

Zuo

Xiong

2019

Scientific Programming

View full text Add to dashboard Cite

Software transactional memory is an effective mechanism to avoid concurrency bugs in multithreaded programs. However, two problems hinder the adoption of such traditional systems in the wild world: high human cost for equipping programs with transaction functionality and low compatibility with I/O calls and conditional variables. This paper presents Convoider to solve these problems. By intercepting interthread operations and designating code among them as transactions in each thread, Convoider automatically transactionalizes target programs without any source code modification and recompiling. By saving/restoring stack frames and CPU registers on beginning/aborting a transaction, Convoider makes execution flow revocable. By turning threads into processes, leveraging virtual memory protection and customizing memory allocation/deallocation, Convoider makes memory manipulations revocable. By maintaining virtual file systems and redirecting I/O operations onto them, Convoider makes I/O effects revocable. By converting lock/unlock operations to no-ops, customizing signal/wait operations on condition variables, and committing memory changes transactionally, Convoider makes deadlocks, data races, and atomicity violations impossible. 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 thirty-one concurrency bugs used in our experiments. This study can help efficiently transactionalize legacy multithreaded applications and effectively improve the runtime reliability of them.

show abstract

A comprehensive study on real world concurrency bugs in Node.js

Cited by 43 publications

References 32 publications

BugsJS: a Benchmark of JavaScript Bugs

BugsJS: a Benchmark of JavaScript Bugs

Atomicity Checking in Linear Time using Vector Clocks

Concurrency Bug Avoiding Based on Optimized Software Transactional Memory

Contact Info

Product

Resources

About