Refactoring sequential Java code for concurrency via concurrent libraries

Parallelizing existing sequential programs to run efficiently on multicores is hard. The Java 5 package java.util.concurrent (j.u.c.) supports writing concurrent programs: much of the complexity of writing thread-safe and scalable programs is hidden in the library. To use this package, programmers s...

Celý popis

Uloženo v:
Podrobná bibliografie
Vydáno v:2009 IEEE 31st International Conference on Software Engineering s. 397 - 407
Hlavní autoři: Dig, Danny, Marrero, John, Ernst, Michael D.
Médium: Konferenční příspěvek
Jazyk:angličtina
Vydáno: Washington, DC, USA IEEE Computer Society 16.05.2009
IEEE
Edice:ACM Conferences
Témata:
Ash
Computing methodologies > Parallel computing methodologies > Parallel programming languages
Concurrent computing
Java
Libraries
Open source software
Packaging
Parallel processing
Programming profession
Software and its engineering > Software creation and management > Software post-development issues > Software reverse engineering
Software and its engineering > Software notations and tools > General programming languages > Language features > Concurrent programming structures
Software and its engineering > Software notations and tools > General programming languages > Language types
Software and its engineering > Software notations and tools > General programming languages > Language types > Parallel programming languages
Writing
Yarn
ISBN:9781424434534, 142443453X
ISSN:0270-5257
On-line přístup:Získat plný text
Tagy: Přidat tag
Žádné tagy, Buďte první, kdo vytvoří štítek k tomuto záznamu!
Popis
Shrnutí:Parallelizing existing sequential programs to run efficiently on multicores is hard. The Java 5 package java.util.concurrent (j.u.c.) supports writing concurrent programs: much of the complexity of writing thread-safe and scalable programs is hidden in the library. To use this package, programmers still need to reengineer existing code. This is tedious because it requires changing many lines of code, is error-prone because programmers can use the wrong APIs, and is omission-prone because programmers can miss opportunities to use the enhanced APIs. This paper presents our tool, Concurrencer, that enables programmers to refactor sequential code into parallel code that uses three j.u.c. concurrent utilities. Concurrencer does not require any program annotations. Its transformations span multiple, non-adjacent, program statements. A find-and-replace tool can not perform such transformations, which require program analysis. Empirical evaluation shows that Concurrencer refactors code effectively: Concurrencer correctly identifies and applies transformations that some open-source developers overlooked, and the converted code exhibits good speedup.
ISBN:9781424434534
142443453X
ISSN:0270-5257
DOI:10.1109/ICSE.2009.5070539