ACM Home Page
Please provide us with feedback. Feedback
From flop to megaflops: Java for technical computing
Full text PdfPdf (372 KB)
Source ACM Transactions on Programming Languages and Systems (TOPLAS) archive
Volume 22 ,  Issue 2  (March 2000) table of contents
Pages: 265 - 295  
Year of Publication: 2000
ISSN:0164-0925
Authors
José E. Moreira  IBM T. J. Watson Research Center, Yorktown Heights, NY
Samuel P. Midkiff  IBM T. J. Watson Research Center, Yorktown Heights, NY
Manish Gupta  IBM T. J. Watson Research Center, Yorktown Heights, NY
Publisher
ACM  New York, NY, USA
Bibliometrics
Downloads (6 Weeks): 10,   Downloads (12 Months): 73,   Citation Count: 11
Additional Information:

abstract   references   cited by   index terms   review   collaborative colleagues   peer to peer  

Tools and Actions: Review this Article  
Save this Article to a Binder    Display Formats: BibTex  EndNote ACM Ref   
DOI Bookmark: Use this link to bookmark this Article: http://doi.acm.org/10.1145/349214.349222
What is a DOI?

ABSTRACT

Although there has been some experimentation with Java as a language for numerically intensive computing, there is a perception by many that the language is unsuited for such work because of performance deficiencies. In this article we show how optimizing array bounds checks and null pointer checks creates loop nests on which aggressive optimizations can be used. Applying these optimizations by hand to a simple matrix-multiply test case leads to Java-compliant programs whose performance is in excess of 500 Mflops on a four-processor 332MHz RS/6000 model F50 computer. We also report in this article the effect that various optimizations have on the performance of six floating-point-intensive benchmarks. Through these optimizations we have been able to achieve with Java at least 80% of the peak Fortran performance on the same benchmarks. Since all of these optimizations can be automated, we conclude that Java will soon be a serious contender for numerically intensive computing.


REFERENCES

Note: OCR errors may be found in this Reference List extracted from the full text article. ACM has opted to expose the complete List rather than only correct and linked references.

 
1
2
 
3
ATWOOD, C. A., GARG, R. P., AND DERYKE, D. 1997. A prototype computational fluid dynamics case study in Java. Concurrency, Pract. Exp. (UK) 9, 11 (November), 1311-1318. Java for Computational Science and Engineering - Simulation and Modeling II Las Vegas, NV, USA 21 June 1997.
 
4
BANERJEE, U. 1990. Unimodular transformations of double loops. In A. NICOLAU ET AL. (Eds.), Advances in Languages and Compilers for Parallel Processing, Third Workshop on Languages and Compilers for Parallel Computing, pp. 192-219. The MIT Press.
 
5
BIK, A. AND GANNON, D. 1998. A prototype bytecode parallelization tool. Concurrency, Pract. Exp. (UK) 10, 11-13 (September-November), 879-886. ACM 1998 Workshop on Java for High- Performance Network Computing. URL: http ://www. cs. ucsb. edu/conferences/j ava98.
 
6
BIK, t., VILLACIS, J., AND GANNON, D. 1997. javar: A prototype Java restructuring compiler. Concurrency, Pract. Exp. (UK) 9, 11 (November), 1181-1191. Java for Computational Science and Engineering - Simulation and Modeling II Las Vegas, NV, USA 21 June 1997.
 
7
BOISVERT, R. F., DONGARRA, J. J., POZO, R., REMINGTON, K. A., AND STEWART, G. W. 1998. Developing numerical libraries in Java. Concurrency, Pract. Exp. (UK) 10, 11-13 (September- November), 1117-1129. ACM 1998 Workshop on Java for High-Performance Network Computing. URL: http ://www. cs. ucsb. edu/conferences/j ava98.
 
8
BUDIMLIC, Z. AND KENNEDY, I~. 1997. Optimizing Java: Theory and practice. Concurrency, Pract. Exp. (UK) 9, 11 (November), 445-463. Java for Computational Science and Engineering - Simulation and Modeling II Las Vegas, NV, USA 21 June 1997.
 
9
BYLER, M., DAVIES, J. R. B., HUSON, C., LEASURE, B., AND WOLFE, M. 1987. Multiple version loops. In Proceedings of the 1987 International Conference on Parallel Processing, pp. 312-318.
10
 
11
CASANOVA, H., DONGARRA, J., AND DOOLIN, D. M. 1997. Java access to numerical libraries. Concurrency, Pract. Exp. (UK) 9, 11 (November), 1279-1291. Java for Computational Science and Engineering - Simulation and Modeling II Las Vegas, NV, USA 21 June 1997.
 
12
CIERNIAK, M. AND LI, W. 1997. Just-in-time optimization for high-performance Java programs. Concurrency, Pract. Exp. (UK) 9, 11 (November), 1063-1073. Java for Computational Science and Engineering - Simulation and Modeling II, Las Vegas, NV, June 21, 1997.
13
14
15
 
16
 
17
 
18
GOSLING, J. 1997. The evolution of numerical computing in Java. URL: http://java, sun. corn/ people/jag/FP.html. Sun Microsystems.
 
19
 
20
GUPTA, M., MIDKIFF, S. P., AND MOREIRA, J. E. 1998. Method for optimizing array bounds checks in programs. Patent pending, IBM Docket ~pYO-998-052, filed with U. S. Patent Office, April 24th, 1998.
21
22
 
23
HARRISON, W. H. 1977. Compiler analysis for the value ranges for variables. IEEE Transactions on Software Engineering SE3, 3 (May), 243-250.
 
24
INTERNATIONAL BUSINESS MACHINES CORPORATION. 1997. IBM Engineering and Scientific Subroutine Library for AIX- Guide and Reference. INTERNATIONAL BUSINESS MACHINES CORPO- RATION.
 
25
JAVA GRANDE FORUM. 1998. Java Grande Forum Report: Making Java Work for High-End Computing. JAVA GRANDE FORUM. Java Grande Forum Panel, SC98, Orlando, FL. URL: http ://www. j avagrande, org/report s. htm.
26
 
27
28
 
29
 
30
MOREIRA, J. E., iV{IDKIFF, S. P., GUPTA, iV{., AND ARTIGAS, P. V. 1999. Numerically Intensive Java. URL: http ://www. alphaWorks, ibm. com/tech/ninj a. A sequential version of the Array package is available for download.
 
31
32
 
33
 
34
 
35
SCHWAB, ~/{. AND SCHROEDER, J. 1998. Algebraic Java classes for numerical optimization. Concurrency, Pract. Exp. (UK) 10, 11-13 (September-November}, 1155-1164. ACM 1998 Workshop on Java for High-Performance Network Computing. URL: http://www.cs.ucsb.edu/ conf erences/j ava98.
36
 
37
SESHADRI, V. 1997. IBM high performance compiler for Java. AIXpert Magazine. URL: http:// www. developer, ibm. com/library/aixpert.
 
38
 
39
 
40

CITED BY  11
 


REVIEW

"Gabriel Mateescu : Reviewer"

For Java to become the language of scientific computing, it must provide execution efficiency close to that of Fortran or C++. This paper identifies the factors limiting the performance of numerically intensive Java programs, and p  more...

Collaborative Colleagues:
José E. Moreira: colleagues
Samuel P. Midkiff: colleagues
Manish Gupta: colleagues

Peer to Peer - Readers of this Article have also read: