Pattern languages of program design 3
Monitors: an operating system structuring concept
Communications of the ACM
Parameterized object sensitivity for points-to analysis for Java
ACM Transactions on Software Engineering and Methodology (TOSEM)
Java Concurrency in Practice
Demand-driven points-to analysis for Java
OOPSLA '05 Proceedings of the 20th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Refactoring support for class library migration
OOPSLA '05 Proceedings of the 20th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Towards concurrency refactoring for x10
Proceedings of the 14th ACM SIGPLAN symposium on Principles and practice of parallel programming
Refactoring sequential Java code for concurrency via concurrent libraries
ICSE '09 Proceedings of the 31st International Conference on Software Engineering
Proceedings of the the 7th joint meeting of the European software engineering conference and the ACM SIGSOFT symposium on The foundations of software engineering
IISWC '09 Proceedings of the 2009 IEEE International Symposium on Workload Characterization (IISWC)
Correct refactoring of concurrent java code
ECOOP'10 Proceedings of the 24th European conference on Object-oriented programming
Refactoring Java programs for flexible locking
Proceedings of the 33rd International Conference on Software Engineering
Hi-index | 0.00 |
Multithread programming is becoming ever-more important to exploit the capabilities of multicore processors. Versions of Java prior to version 5 provide only the synchronized construct as a consistency primitive, which causes a performance scalability problem for multicore machines. Therefore, Java 5 added the java.util.concurrent package to reduce lock contention. Programmers must manually rewrite their existing code to use this package in existing programs. There are two typical rewritings methods. One is to replace an operation on a variable within a synchronized block with an atomic-lock-free version. The other is to replace a sequential concurrent class with its concurrent version. The conventional rewriting approach has three deficiencies. One problem is transformations that may change the behavior of a program. The second problem is missed modifications to be rewritten. The third problem is two difference writing techniques are applied individually to each code fragment even in the same method. This paper describes our refactoring algorithms that address these three problems as they rewrite Java code for scalable performance. We use inter-procedural pointer analysis and consistency tests among the candidate code fragments.