Refactoring sequential Java code for concurrency via concurrent libraries

Dig, Danny; Marrero, John; Ernst, M.

doi:10.1109/icse.2009.5070539

Cited by 120 publications

(90 citation statements)

References 9 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The programmer can decide to (i) synchronize accesses to such data, or (ii) remove either its mutability or shared-ness. Our toolset supports two refactorings for synchronizing accesses to data: one refactoring [7] converts an int field to an AtomicInteger, a j.u.c. library class which provides atomic operations for field updates.…”

Section: A Refactorings For Thread-safetymentioning

confidence: 99%

“…Our growing toolset [7]- [9] of refactorings for parallelism uses the workflow described above (see more details in Section III). The experience with replicating refactoring scenarios performed by open-source developers shows that automation is useful.…”

Section: A Vision For Refactoring Tools For Parallelismmentioning

confidence: 99%

“…Our toolset supports two such refactorings. One refactoring [7] converts a sequential divide-and-conquer algorithm into an algorithm which solves the recursive subproblems in parallel using Java's ForkJoinTask framework [14]. Another refactoring parallelizes loops over arrays.…”

Section: B Refactorings For Throughputmentioning

confidence: 99%

See 2 more Smart Citations

A Refactoring Approach to Parallelism

Dig

2011

IEEE Softw.

Self Cite

View full text Add to dashboard Cite

Abstract-In the multicore era, a major programming task will be to make programs more parallel. This is tedious because it requires changing many lines of code, and it is error-prone and non-trivial because programmers need to ensure non-interference of parallel operations. Fortunately, refactoring tools can help reduce the analysis and transformation burden.We present our vision on how refactoring tools can improve programmer productivity, program performance, and program portability. We also present the current incarnation of this vision: a toolset that supports several refactorings for (i) making programs thread-safe, (ii) threading sequential programs for throughput, and (iii) improving scalability of parallel programs.

show abstract

Section: A Refactorings For Thread-safetymentioning

confidence: 99%

Section: A Vision For Refactoring Tools For Parallelismmentioning

confidence: 99%

See 1 more Smart Citation

A Refactoring Approach to Parallelism

Dig

2011

IEEE Softw.

Self Cite

View full text Add to dashboard Cite

show abstract

“…Unlike the work presented here, the technique is limited to Erlang and does not evaluate reductions in development time. Other work on parallel refactoring has mostly considered loop parallelisation in Fortran [21] and Java [9]. However, these approaches are limited to concrete and simple structural changes (e.g.…”

Section: Related Workmentioning

confidence: 99%

RPL: A Domain-Specific Language for Designing and Implementing Parallel C++ Applications

Janjić

Brown

MacKenzie

et al. 2016

2016 24th Euromicro International Conference on Parallel, Distributed, and Network-Based Processing (PDP)

View full text Add to dashboard Cite

Abstract-Parallelising sequential applications is usually a very hard job, due to many different ways in which an application can be parallelised and a large number of programming models (each with its own advantages and disadvantages) that can be used. In this paper, we describe a method to semiautomatically generate and evaluate different parallelisations of the same application, allowing programmers to find the best parallelisation without significant manual reengineering of the code. We describe a novel, high-level domain-specific language, Refactoring Pattern Language (RPL), that is used to represent the parallel structure of an application and to capture its extrafunctional properties (such as service time). We then describe a set of RPL rewrite rules that can be used to generate alternative, but semantically equivalent, parallel structures (parallelisations) of the same application. We also describe the RPL Shell that can be used to evaluate these parallelisations, in terms of the desired extra-functional properties. Finally, we describe a set of C++ refactorings, targeting OpenMP, Intel TBB and FastFlow parallel programming models, that semi-automatically apply the desired parallelisation to the application's source code, therefore giving a parallel version of the code. We demonstrate how the RPL and the refactoring rules can be used to derive efficient parallelisations of two realistic C++ use cases (Image Convolution and Ant Colony Optimisation).

show abstract

“…Therefore, it is important to precisely map the entities between versions so as to reduce the noise in gathering the change feature. Refactoring [11,49] is an important type of changes in objectoriented software, which changes the structure of a program without affecting its behavior [13]. As there exist many refactoring tools [10,55], we will use these…”

mentioning

confidence: 99%

Is This a Bug or an Obsolete Test?

Hao

Lan

Zhang

et al. 2013

ECOOP 2013 – Object-Oriented Programming

View full text Add to dashboard Cite

Abstract. In software evolution, developers typically need to identify whether the failure of a test is due to a bug in the source code under test or the obsoleteness of the test code when they execute a test suite. Only after finding the cause of a failure can developers determine whether to fix the bug or repair the obsolete test. Researchers have proposed several techniques to automate test repair. However, test-repair techniques typically assume that test failures are always due to obsolete tests. Thus, such techniques may not be applicable in real world software evolution when developers do not know whether the failure is due to a bug or an obsolete test. To know whether the cause of a test failure lies in the source code under test or in the test code, we view this problem as a classification problem and propose an automatic approach based on machine learning. Specifically, we target Java software using the JUnit testing framework and collect a set of features that may be related to failures of tests. Using this set of features, we adopt the Best-first Decision Tree Learning algorithm to train a classifier with some existing regression test failures as training instances. Then, we use the classifier to classify future failed tests. Furthermore, we evaluated our approach using two Java programs in three scenarios (within the same version, within different versions of a program, and between different programs), and found that our approach can effectively classify the causes of failed tests.

show abstract

Refactoring sequential Java code for concurrency via concurrent libraries

Abstract: Parallelizing existing sequential programs to run efficiently on multicores is hard. The Java 5 package java.util.concurrent (j.u.c.)

Cited by 120 publications

References 9 publications

A Refactoring Approach to Parallelism

A Refactoring Approach to Parallelism

RPL: A Domain-Specific Language for Designing and Implementing Parallel C++ Applications

Is This a Bug or an Obsolete Test?

Contact Info

Product

Resources

About