Analyzing Concurrent Programs Title for Potential Programming Errors

2011 ◽  
pp. 380-415
Author(s):  
Qichang Chen ◽  
Liqiang Wang ◽  
Ping Guo ◽  
He Huang
Keyword(s):  
Shared Memory ◽  
Message Passing ◽  
Programming Models ◽  
Concurrent Programs ◽  
Sequential Programs ◽  
Multithreaded Programming ◽  
Testing And Debugging ◽  
Race Condition ◽  
Art Research ◽  
Concurrency Errors

Today, multi-core/multi-processor hardware has become ubiquitous, leading to a fundamental turning point on software development. However, developing concurrent programs is difficult. Concurrency introduces the possibility of errors that do not exist in sequential programs. This chapter introduces the major concurrent programming models including multithreaded programming on shared memory and message passing programming on distributed memory. Then, the state-of-the-art research achievements on detecting concurrency errors such as deadlock, race condition, and atomicity violation are reviewed. Finally, the chapter surveys the widely used tools for testing and debugging concurrent programs.

BAVC: Classifying Benign Atomicity Violations via Machine Learning

2013 ◽  
Vol 765-767 ◽  
pp. 1576-1580 ◽  
Author(s):  
Qi Chang Chen ◽  
Zhan Fang Chen ◽  
Zhuang Liu ◽  
Xin Feng ◽  
Zhen Gang Jiang ◽  
...  
Keyword(s):  
Machine Learning ◽  
Code Region ◽  
Machine Learning Techniques ◽  
Support Vector ◽  
Concurrent Programs ◽  
Testing And Debugging ◽  
Atomicity Violation ◽  
Learning Techniques ◽  
Concurrency Errors ◽  
Atomicity Violations

The reality of multi-core hardware has made concurrent programs pervasive. Unfortunately, writing correct concurrent programs is difficult. Atomicity violation, which is caused by concurrent executions unexpectedly violating the atomicity of a certain code region, is one of the most common concurrency errors. However, atomicity violation bugs are hard to find using traditional testing and debugging techniques. In this paper, we investigate an approach based on machine learning techniques (specifically decision tree and support vector machine (SVM)) for classifying the benign atomicity violations from the harmful ones. A benign atomicity violation is known not to affect the program's correctness even it happens. We formulate our problem as a supervised-learning problem and apply these two machine learning techniques to classify the atomicity violation report. Our experimental evaluation shows that the proposed method is effective in identifying the benign atomicity violation warnings.

scholarly journals Data Flow Testing in Concurrent Programs with Message Passing and Shared Memory Paradigms

2013 ◽  
Vol 18 ◽  
pp. 149-158 ◽  
Author(s):  
Paulo S.L. Souza ◽  
Simone S. Souza ◽  
Murilo G. Rocha ◽  
Rafael R. Prado ◽  
Raphael N. Batista
Keyword(s):  
Shared Memory ◽  
Message Passing ◽  
Data Flow ◽  
Concurrent Programs ◽  
Data Flow Testing

scholarly journals Trace Generation and Deterministic Execution for Concurrent Programs

2016 ◽  
Author(s):  
Paulo Souza ◽  
Raphael Batista ◽  
Simone Souza ◽  
Rafael Prado ◽  
George Dourado ◽  
...  
Keyword(s):  
Shared Memory ◽  
Message Passing ◽  
Source Code ◽  
Concurrent Programs ◽  
Code Coverage ◽  
Coverage Testing ◽  
Point To Point ◽  
New Algorithms

This paper proposes new algorithms for generation of trace files and deterministic execution of concurrent programs under test. The proposed algorithms are essential to automate the coverage testing of concurrent programs and allow to execute new synchronizations automatically, increasing the source code coverage with focus on non-determinism, and edges of communication and synchronization. Our algorithms consider programs with multiple paradigms of communication and synchronization (collective, blocking and non-blocking point-to-point message passing, and shared memory). We validate our algorithms by means of experiments based on nine representative benchmarks, which exercise non-trivial aspects of synchronization found in real applications. Our algorithms have a robust behaviour and meet their objectives. We also highlight the overhead generated with the algorithms.

Causal-Consistent Replay Reversible Semantics for Message Passing Concurrent Programs

2021 ◽  
Vol 178 (3) ◽  
pp. 229-266
Author(s):  
Ivan Lanese ◽  
Adrián Palacios ◽  
Germán Vidal
Keyword(s):  
Programming Language ◽  
Message Passing ◽  
Concurrent Programming ◽  
Concurrent Systems ◽  
Concurrent Programs ◽  
Unified Framework ◽  
Innovative Technique ◽  
Dual Notion

Causal-consistent reversible debugging is an innovative technique for debugging concurrent systems. It allows one to go back in the execution focusing on the actions that most likely caused a visible misbehavior. When such an action is selected, the debugger undoes it, including all and only its consequences. This operation is called a causal-consistent rollback. In this way, the user can avoid being distracted by the actions of other, unrelated processes. In this work, we introduce its dual notion: causal-consistent replay. We allow the user to record an execution of a running program and, in contrast to traditional replay debuggers, to reproduce a visible misbehavior inside the debugger including all and only its causes. Furthermore, we present a unified framework that combines both causal-consistent replay and causal-consistent rollback. Although most of the ideas that we present are rather general, we focus on a popular functional and concurrent programming language based on message passing: Erlang.

Parallel Nonnegative Matrix Factorization via Newton Iteration

2016 ◽  
Vol 26 (03) ◽  
pp. 1650014 ◽  
Author(s):  
Markus Flatz ◽  
Marián Vajteršic
Keyword(s):  
Shared Memory ◽  
Matrix Factorization ◽  
Message Passing ◽  
Nonnegative Matrix Factorization ◽  
Nonnegative Matrix ◽  
Newton Iteration ◽  
Parallel Execution ◽  
Kkt Conditions ◽  
Nonnegative Matrices ◽  
First Order

The goal of Nonnegative Matrix Factorization (NMF) is to represent a large nonnegative matrix in an approximate way as a product of two significantly smaller nonnegative matrices. This paper shows in detail how an NMF algorithm based on Newton iteration can be derived using the general Karush-Kuhn-Tucker (KKT) conditions for first-order optimality. This algorithm is suited for parallel execution on systems with shared memory and also with message passing. Both versions were implemented and tested, delivering satisfactory speedup results.

An Efficient Parallel Algorithm for Extreme Eigenvalues of Sparse Nonsymmetric Matrices

1992 ◽  
Vol 6 (1) ◽  
pp. 98-111 ◽  
Author(s):  
S. K. Kim ◽  
A. T. Chrortopoulos
Keyword(s):  
Shared Memory ◽  
Message Passing ◽  
Sparse Matrices ◽  
Data Locality ◽  
Main Memory ◽  
Global Memory ◽  
Global Communication ◽  
Step Method ◽  
Arnoldi Algorithm ◽  
Large Sparse Matrices

Main memory accesses for shared-memory systems or global communications (synchronizations) in message passing systems decrease the computation speed. In this paper, the standard Arnoldi algorithm for approximating a small number of eigenvalues, with largest (or smallest) real parts for nonsymmetric large sparse matrices, is restructured so that only one synchronization point is required; that is, one global communication in a message passing distributed-memory machine or one global memory sweep in a shared-memory machine per each iteration is required. We also introduce an s-step Arnoldi method for finding a few eigenvalues of nonsymmetric large sparse matrices. This method generates reduction matrices that are similar to those generated by the standard method. One iteration of the s-step Arnoldi algorithm corresponds to s iterations of the standard Arnoldi algorithm. The s-step method has improved data locality, minimized global communication, and superior parallel properties. These algorithms are implemented on a 64-node NCUBE/7 Hypercube and a CRAY-2, and performance results are presented.

scholarly journals Parallel programming technologies on computer complexes

2020 ◽  
Vol 30 (3) ◽  
pp. 28-33 ◽  
Author(s):  
S. A. Pryadko ◽  
A. Yu. Troshin ◽  
V. D. Kozlov ◽  
A. E. Ivanov
Keyword(s):  
Parallel Programming ◽  
Shared Memory ◽  
Programming Language ◽  
Operating Systems ◽  
Distributed Memory ◽  
Programming Models ◽  
Writing Programs ◽  
Advantages And Disadvantages ◽  
C Programming Language ◽  
C Programming

The article describes various options for speeding up calculations on computer systems. These features are closely related to the architecture of these complexes. The objective of this paper is to provide necessary information when selecting the capability for the speeding process of solving the computation problem. The main features implemented using the following models are described: programming in systems with shared memory, programming in systems with distributed memory, and programming on graphics accelerators (video cards). The basic concept, principles, advantages, and disadvantages of each of the considered programming models are described. All standards for writing programs described in the article can be used both on Linux and Windows operating systems. The required libraries are available and compatible with the C/C++ programming language. The article concludes with recommendations on the use of a particular technology, depending on the type of task to be solved.

Sign in / Sign up

Export Citation Format

Share Document