WILEY Journal Home Page
Papers under review through 2004
| Publisher | John Wiley Sons, Ltd. Chichester, UK | ||||||||
| Category | Research Article | ||||||||
| Article Title | A stochastic load balancing algorithm for Computing | ||||||||
| Volume ID | 15 | ||||||||
| Issue ID | 1 | ||||||||
| Date | Jan 1 2003 | ||||||||
| DOI(URI) | http://dx.doi.org/10.1002/cpe.708 | ||||||||
| Article ID | CPE708 | ||||||||
| Author Name(s) | Yuk Yin Wong1Kwong Sak Leung2Kin Hong Lee3 | ||||||||
| Author Email(s) | clevin.wong@cityu.edu.hk1 | ||||||||
| Affiliation(s) | Computing Services Centre, City University of Hong Kong, Tat Chee Avenue, Kln., Hong Kong 1>Department of Computer Science and Engineering, Chinese University of Hong Kong, Shatin, N.T., Hong 2 3 | ||||||||
| Keyword(s) | Internet computing, stochastic load balancing, distributed systems, Java computing, | ||||||||
Abstract |
|||||||||
| This paper presents a stochastic dynamic load balancing algorithm for Internet computing, which is a new type of distributed computing involving heterogeneous workstations from different organizations on the Internet. To realize the practical environment, we assume the system to be comprised of heterogeneous,untrusted and non dedicated workstations connected by a non dedicated network. Our algorithm uses the product of the average processing time and the queue length of system jobs as the load index. Dynamic communication delay is included in the execution cost calculation. The transfer policy and the location policy are combined in a stochastic algorithm. State information exchange is done via information feedback and mutual updating. Simulations demonstrate that our algorithm outperforms conventional approaches over a wide range of system parameters. These results are reconfirmed by empirical experiments after we have implemented the algorithms on the Distributed Java Machine global virtual machine. Copyright 2003 John Wiley Sons, Ltd. | |||||||||
| Publisher | John Wiley Sons, Ltd. Chichester, UK | ||||||||
| Category | Research Article | ||||||||
| Article Title | A comparison of concurrent programming and cooperative multithreading | ||||||||
| Volume ID | 15 | ||||||||
| Issue ID | 1 | ||||||||
| Date | Jan 1 2003 | ||||||||
| DOI(URI) | http://dx.doi.org/10.1002/cpe.706 | ||||||||
| Article ID | CPE706 | ||||||||
| Author Name(s) | Ronald A Olsson1Tiejun Li2Eugene F. Fodor3Aaron W. Keen4 | ||||||||
| Author Email(s) | olsson@cs.ucdavis.edu1 | ||||||||
| Affiliation(s) | Department of Computer Science, University of California, Davis, CA 95616, U.S.A. 1 2 3 4 | ||||||||
| Keyword(s) | cooperative multithreading, concurrent programming, parallel and distributed programming languages, synchronization mechanisms, synchronization optimization, | ||||||||
Abstract |
|||||||||
| This paper presents a comparison of the cooperative multithreading model with the general concurrent programming model.It focuses on the execution time performance of a range of standard concurrent programming applications. The overall results are mixed. In some cases, programs written in the cooperative multithreading model outperform those written in the general concurrent programming model. The contributions of this paper are twofold. First, it presents a thorough analysis of the performances of applications in the different models, i.e. to explain the criteria that determine when a program in one model will outperform an equivalent program in the other. Second, it examines the tradeoffs in writing programs in the different programming styles. In some cases, better performance comes at the cost of more complicated code. Copyright 2003 John Wiley Sons, Ltd. | |||||||||
| Publisher | John Wiley Sons, Ltd. Chichester, UK | ||||||||
| Category | Research Article | ||||||||
| Article Title | The Virtual Laboratory: a toolset to enable distributed molecular modelling for drug design on the World Wide Grid | ||||||||
| Volume ID | 15 | ||||||||
| Issue ID | 1 | ||||||||
| Date | Jan 1 2003 | ||||||||
| DOI(URI) | http://dx.doi.org/10.1002/cpe.704 | ||||||||
| Article ID | CPE704 | ||||||||
| Author Name(s) | Rajkumar Buyya1Kim Branson2Jon Giddy3DavidA Abramson4 | ||||||||
| Author Email(s) | rajkumar@buyya.com1 | ||||||||
| Affiliation(s) | Grid Computing and Distributed Systems Laboratory, Department of Computer Science and Software Engin 1Structural Biology, Walter and Eliza Hall Institute, Royal Parade, Parkville, Melbourne, Australia 2Welsh Science Centre, Department of Computer Science, Cardiff University, Cardiff, U.K. 3School of Computer Science and Software Engineering, Monash University, Caulfield Campus, Melbourne 4 | ||||||||
| Keyword(s) | Grid computing, drug design, application scheduling, grid economy, | ||||||||
Abstract |
|||||||||
| Computational Grids are emerging as a new paradigm for sharing and aggregation of geographically distributed resources for solving large scale compute and data intensive problems in science, engineering and commerce. However, application development, resource management and scheduling in these environments is a complex undertaking. In this paper, we illustrate the development of a Virtual Laboratory environment by leveraging existing Grid technologies to enable molecular modelling for drug design on geographically distributed resources. It involves screening millions of compounds in the chemical database CDB against a protein target to identify those with potential use for drug design. We have used the Nimrod G parameter specification language to transform the existing molecular docking application into a parameter sweep application for executing on distributed systems. We have developed new tools for enabling access to ligand records ;molecules in the CDB from remote resources. The Nimrod G resource broker along with molecule CDB data broker is used for scheduling and on demand processing of docking jobs on the World Wide Grid ;WWG ; resources. The results demonstrate the ease of use and power of the Nimrod G and virtual laboratory tools for grid computing. Copyright 2003 John Wiley Sons, Ltd. | |||||||||
| Publisher | John Wiley Sons, Ltd. Chichester, UK | ||||||||
| Category | Research Article | ||||||||
| Article Title | Object oriented distributed computing based on remote class reference | ||||||||
| Volume ID | 15 | ||||||||
| Issue ID | 1 | ||||||||
| Date | Jan 1 2003 | ||||||||
| DOI(URI) | http://dx.doi.org/10.1002/cpe.708 | ||||||||
| Article ID | CPE709 | ||||||||
| Author Name(s) | David W. Walker1Yan Huang2Omer F. Rana3 | ||||||||
| Author Email(s) | David.W.Walker@cs.cf.ac.uk1 | ||||||||
| Affiliation(s) | Department of Computer Science, Cardiff University, P.O. Box 916, Cardiff CF24 3XF, U.K 1 2 3 | ||||||||
| Keyword(s) | Java, RMI, distributed computing, remote class reference, | ||||||||
Abstract |
|||||||||
| Java RMI, Jini and CORBA provide effective mechanisms for implementing a distributed computing system. Recently many numeral libraries have been developed that take advantage of Java as an object oriented and portable language.The widely used client server method limits the extent to which the benefits of the object oriented approach can be exploited because of the difficulties arising when a remote object is the argument or return value of a remote or local method. In this paper this problem is solved by introducing a data object that stores the data structure of the remote object and related access methods. By using this data object, the client can easily instantiate a remote object, and use it as the argument or return value of either a local or remote method. Copyright 2003 John Wiley Sons, Ltd. | |||||||||
| Publisher | John Wiley Sons, Ltd. Chichester, UK | ||||||||
| Category | Research Article | ||||||||
| Article Title | Modular specification of frame properties in JML | ||||||||
| Volume ID | 15 | ||||||||
| Issue ID | 2 | ||||||||
| Date | Feb 1 2003 | ||||||||
| DOI(URI) | http://dx.doi.org/10.1002/cpe.713 | ||||||||
| Article ID | CPE713 | ||||||||
| Author Name(s) | Gary T. Leavens1Arnd Poetzsch-Heffter2Peter Müller3 | ||||||||
| Author Email(s) | leavens@cs.iastate.edu1 | ||||||||
| Affiliation(s) | Department of Computer Science, Iowa State University, 229 Atanasoff Hall, Ames, IA 50011-1040, U.S. 1Universität Kaiserslautern, 67653 Kaiserslautern, Germany 2Deutsche Bank AG, Frankfurt, Germany 3 | ||||||||
| Keyword(s) | formal specification, frame problem, depends-clause, modifies-clause, JML, alias control, ownership, Java, | ||||||||
Abstract |
|||||||||
| We present a modular specification technique for frame properties. The technique uses modifies clauses and abstract fields with declared dependencies. Modularity is guaranteed by a programming model that enforces data abstraction by preventing representation and argument exposure, a semantics of modifies clauses that uses a notion of 'relevant location', and by modularity rules for dependencies. For concreteness, we adapt this technique to the Java Modeling Language, JML. Copyright © 2003 John Wiley & Sons, Ltd. | |||||||||
| Publisher | John Wiley Sons, Ltd. Chichester, UK | ||||||||
| Category | Research Article | ||||||||
| Article Title | Improving the official specification of Java bytecode verification | ||||||||
| Volume ID | 15 | ||||||||
| Issue ID | 2 | ||||||||
| Date | Feb 1 2003 | ||||||||
| DOI(URI) | http://dx.doi.org/10.1002/cpe.714 | ||||||||
| Article ID | CPE714 | ||||||||
| Author Name(s) | Alessandro Coglio1 | ||||||||
| Author Email(s) | coglio@kestrel.edu1 | ||||||||
| Affiliation(s) | Kestrel Institute, 3260 Hillview Avenue, Palo Alto, CA 94304, U.S.A. 1 | ||||||||
| Keyword(s) | Java, bytecode verification, specification, | ||||||||
Abstract |
|||||||||
| Bytecode verification is the main mechanism to ensure type safety in the Java Virtual Machine. Inadequacies in its official specification may lead to incorrect implementations where security can be broken and/or certain legal programs are rejected. This paper provides a comprehensive analysis of the specification, along with concrete suggestions for improvement. Copyright © 2003 John Wiley & Sons, Ltd. | |||||||||
| Publisher | John Wiley Sons, Ltd. Chichester, UK | ||||||||
| Category | Research Articles | ||||||||
| Article Title | Clustering revealed in high-resolution simulations and visualization of multi-resolution features in fluid-particle models | ||||||||
| Volume ID | 15 | ||||||||
| Issue ID | 2 | ||||||||
| Date | Feb 1 2003 | ||||||||
| DOI(URI) | http://dx.doi.org/10.1002/cpe.711 | ||||||||
| Article ID | CPE711 | ||||||||
| Author Name(s) | David A. Yuen1Krzysztof Boryczko2Witold Dzwinel3 | ||||||||
| Author Email(s) | davey@krissy.msi.umn.edu1 | ||||||||
| Affiliation(s) | Minnesota Supercomputing Institute, University of Minnesota, Minneapolis, MN 55455-1227, U.S. 11AGH Institute of Computer Science, al. Mickiewicza 30, 30-059, Kraków, Poland 2 3 | ||||||||
| Keyword(s) | large-scale data sets, visualization, feature extraction, parallel clustering, dissipative particle dynamics, fluid particle model, | ||||||||
Abstract |
|||||||||
| Simulating natural phenomena at greater accuracy results in an explosive growth of data. Large-scale simulations with particles currently involve ensembles consisting of between 106 and 109 particles, which cover 105-106 time steps. Thus, the data files produced in a single run can reach from tens of gigabytes to hundreds of terabytes. This data bank allows one to reconstruct the spatio-temporal evolution of both the particle system as a whole and each particle separately. Realistically, for one to look at a large data set at full resolution at all times is not possible and, in fact, not necessary. We have developed an agglomerative clustering technique, based on the concept of a mutual nearest neighbor (MNN). This procedure can be easily adapted for efficient visualization of extremely large data sets from simulations with particles at various resolution levels. We present the parallel algorithm for MNN clustering and its timings on the IBM SP and SGI/Origin 3800 multiprocessor systems for up to 16 million fluid particles. The high efficiency obtained is mainly due to the similarity in the algorithmic structure of MNN clustering and particle methods. We show various examples drawn from MNN applications in visualization and analysis of the order of a few hundred gigabytes of data from discrete particle simulations, using dissipative particle dynamics and fluid particle models. Because data clustering is the first step in this concept extraction procedure, we may employ this clustering procedure to many other fields such as data mining, earthquake events and stellar populations in nebula clusters. Copyright © 2003 John Wiley & Sons, Ltd. | |||||||||
| Publisher | John Wiley Sons, Ltd. Chichester, UK | ||||||||
| Category | Research Article | ||||||||
| Article Title | MPI-CHECK: a tool for checking Fortran 90 MPI programs | ||||||||
| Volume ID | 15 | ||||||||
| Issue ID | 2 | ||||||||
| Date | Feb 1 2003 | ||||||||
| DOI(URI) | http://dx.doi.org/10.1002/cpe.705 | ||||||||
| Article ID | CPE705 | ||||||||
| Author Name(s) | Glenn Luecke1Hua Chen2James Coyle3Jim Hoekstra4Yan Zou5Marina Kraeva6 | ||||||||
| Author Email(s) | grl@iastate.edu1 | ||||||||
| Affiliation(s) | High Performance Computing Group, Iowa State University, Ames, IA 50011, U.S.A. 1 2 3 4 5 6 | ||||||||
| Keyword(s) | MPI, tool, bounds checking, argument checking, data type checking, | ||||||||
Abstract |
|||||||||
| MPI is commonly used to write parallel programs for distributed memory parallel computers. MPI-CHECK is a tool developed to aid in the debugging of MPI programs that are written in free or fixed format Fortran 90 and Fortran 77. MPI-CHECK provides automatic compile-time and run-time checking of MPI programs. MPI-CHECK automatically detects the following problems in the use of MPI routines: (i) mismatch in argument type, kind, rank or number; (ii) messages which exceed the bounds of the source/destination array; (iii) negative message lengths; (iv) illegal MPI calls before MPI_INIT or after MPI_FINALIZE; (v) inconsistencies between the declared type of a message and its associated DATATYPE argument; and (vi) actual arguments which violate the INTENT attribute. Copyright © 2003 John Wiley & Sons, Ltd. | |||||||||
| Publisher | John Wiley Sons, Ltd. Chichester, UK | ||||||||
| Category | Research Article | ||||||||
| Article Title | Kava: a Java dialect with a uniform object model for lightweight classes | ||||||||
| Volume ID | 15 | ||||||||
| Issue ID | 3-5 | ||||||||
| Date | March 1 2003 | ||||||||
| DOI(URI) | http://dx.doi.org/10.1002/cpe.653 | ||||||||
| Article ID | CPE653 | ||||||||
| Author Name(s) | David F. Bacon1 | ||||||||
| Author Email(s) | dfb@watson.ibm.com1 | ||||||||
| Affiliation(s) | IBM T.J. Watson Research Center, P.O. Box 704, Yorktown Heights, NY 10598, U.S.A 1 | ||||||||
| Keyword(s) | Java, lightweight classes, object inlining, object models, unboxing, | ||||||||
Abstract |
|||||||||
| Object-oriented programming languages have always distinguished between 'primitive' and 'user-defined' data types, and in the case of languages like C++ and Java the primitives are not even treated as objects, further fragmenting the programming model. The distinction is especially problematic when a particular programming community requires primitive-level support for a new data type, as for complex, intervals, fixed-point numbers, and so on. We present Kava, a design for a backward-compatible version of Java that solves the problem of programmable lightweight objects in a much more aggressive and uniform manner than previous proposals. In Kava, there are no primitive types; instead, object-oriented programming is provided down to the level of single bits, and types such as int can be explicitly programmed within the language. While the language maintains a uniform object reference semantics, efficiency is obtained by making heavy use of unboxing and semantic expansion. We describe Kava as a dialect of the Java language, show how it can be used to define various primitive types, describe how it can be translated into Java, and compare it to other approaches to lightweight objects. Copyright © 2003 John Wiley & Sons, Ltd. | |||||||||
| Publisher | John Wiley Sons, Ltd. Chichester, UK | ||||||||
| Category | Research Article | ||||||||
| Article Title | Framework for testing multi-threaded Java programs | ||||||||
| Volume ID | 15 | ||||||||
| Issue ID | 3-5 | ||||||||
| Date | March 1 2003 | ||||||||
| DOI(URI) | http://dx.doi.org/10.1002/cpe.654 | ||||||||
| Article ID | CPE654 | ||||||||
| Author Name(s) | Shmuel Ur1Orit Edelstein2Eitan Farchi3Evgeny Goldin4Gil Ratsaby5 | ||||||||
| Author Email(s) | UR@il.ibm.com1 Correspondence to Shmuel Ur, IBM Research Laboratory in Haifa5 | ||||||||
| Affiliation(s) | Correspondence to Shmuel Ur, IBM Research Laboratory in Haifa 1 2 3 4 5 | ||||||||
| Keyword(s) | ., | ||||||||
Abstract |
|||||||||
| Finding bugs due to race conditions in multi-threaded programs is difficult, mainly because there are many possible interleavings, any of which may contain a fault. In this work we present a methodology for testing multi-threaded programs which has minimal impact on the user and is likely to find interleaving bugs. Our method reruns existing tests in order to detect synchronization faults. We find that a single test executed a number of times in a controlled environment may be as effective in finding synchronization faults as many different tests. A great deal of resources are saved since tests are very expensive to write and maintain. We observe that simply rerunning tests, without ensuring in some way that the interleaving will change, yields almost no benefits. We implement the methodology in our test generation tool - ConTest. ConTest combines the replay algorithm, which is essential for debugging, with our interleaving test generation heuristics. ConTest also contains an instrumentation engine, a coverage analyzer, and a race detector (not finished yet) that enhance bug detection capabilities. The greatest advantage of ConTest, besides finding bugs of course, is its minimal effect on the user. When ConTest is combined into the test harness, the user may not even be aware that ConTest is being used. Copyright © 2003 John Wiley & Sons, Ltd. | |||||||||
| Publisher | John Wiley Sons, Ltd. Chichester, UK | ||||||||
| Category | Research Article | ||||||||
| Article Title | Integration and application of TAU in parallel Java environments | ||||||||
| Volume ID | 15 | ||||||||
| Issue ID | 3-5 | ||||||||
| Date | March 1 2003 | ||||||||
| DOI(URI) | http://dx.doi.org/10.1002/cpe.655 | ||||||||
| Article ID | CPE655 | ||||||||
| Author Name(s) | Sameer Shende1Allen D. Malony2 | ||||||||
| Author Email(s) | sameer@cs.uoregon.edu1 | ||||||||
| Affiliation(s) | Department of Computer and Information Science, 1202 University of Oregon, Eugene, OR 97403, U.S.A. 1Department of Computer and Information Science, 1202 University of Oregon, Eugene, OR 97403, U.S.A. 2 | ||||||||
| Keyword(s) | parallel, Java, performance, tools, | ||||||||
Abstract |
|||||||||
| Parallel Java environments present challenging problems for performance tools because of Java's rich language system and its multi-level execution platform combined with the integration of native-code application libraries and parallel run-time software. In addition to the desire to provide robust performance measurement and analysis capabilities for the Java language itself, the coupling of different software execution contexts under a uniform performance model needs careful consideration of how events of interest are observed and how cross-context parallel execution information is linked. This paper relates our experience in extending the TAU (Tuning and Analysis Utilities) performance system to a parallel Java environment based on mpiJava. We describe the complexities of the instrumentation model used, how performance measurements are made, and the overhead incurred. A parallel Java application simulating the game of Life is used to show the performance system's capabilities. Copyright © 2003 John Wiley & Sons, Ltd. | |||||||||
| Publisher | John Wiley Sons, Ltd. Chichester, UK | ||||||||
| Category | Research Article | ||||||||
| Article Title | Platform independent dynamic Java virtual machine analysis: the Java Grande Forum benchmark suite | ||||||||
| Volume ID | 15 | ||||||||
| Issue ID | 3-5 | ||||||||
| Date | March 1 2003 | ||||||||
| DOI(URI) | http://dx.doi.org/10.1002/cpe.666 | ||||||||
| Article ID | CPE666 | ||||||||
| Author Name(s) | John Waldron1James Power2David Gregg3 | ||||||||
| Author Email(s) | John.Waldron@cs.tcd.ie1 | ||||||||
| Affiliation(s) | Department of Computer Science, Trinity College, Dublin 2, Ireland 1Department of Computer Science, National University of Ireland, Maynooth, Co. Kildare, Ireland 2 3 | ||||||||
| Keyword(s) | Java Virtual Machine, Java Grande, instruction frequency, method profiling, | ||||||||
Abstract |
|||||||||
| In this paper we present a platform independent analysis of the dynamic profiles of Java programs when executing on the Java Virtual Machine. The Java programs selected are taken from the Java Grande Forum benchmark suite and five different Java-to-bytecode compilers are analysed. The results presented describe the dynamic instruction usage frequencies, as well as the sizes of the local variable, parameter and operand stacks during execution on the JVM. These results, presenting a picture of the actual (rather than presumed) behaviour of the JVM, have implications both for the coverage aspects of the Java Grande benchmark suites, for the performance of the Java-to-bytecode compilers and for the design of the JVM. Copyright © 2003 John Wiley & Sons, Ltd. | |||||||||
| Publisher | John Wiley Sons, Ltd. Chichester, UK | ||||||||
| Category | Research Article | ||||||||
| Article Title | High-performance Java codes for computational fluid dynamics | ||||||||
| Volume ID | 15 | ||||||||
| Issue ID | 3-5 | ||||||||
| Date | March 1 2003 | ||||||||
| DOI(URI) | http://dx.doi.org/10.1002/cpe.656 | ||||||||
| Article ID | CPE656 | ||||||||
| Author Name(s) | Christopher J. Riley1Siddhartha Chatterjee2Rupak Biswas3 | ||||||||
| Author Email(s) | chris.riley@cfdesign.com1 | ||||||||
| Affiliation(s) | Blue Ridge Numerics, Inc., Charlottesville, VA 22901, U.S.A 1IBM T. J. Watson Research Center, Yorktown Heights, NY 10598, U.S.A. 2NASA Advanced Supercomputing Division, MS T27A-1, NASA Ames Research Center, Moffett Field, CA 94035 3 | ||||||||
| Keyword(s) | scientific computing, object-oriented, benchmarks, | ||||||||
Abstract |
|||||||||
| The computational science community is reluctant to write large-scale computationally-intensive applications in Java due to concerns over Java's poor performance, despite the claimed software engineering advantages of its object-oriented features. Naive Java implementations of numerical algorithms can perform poorly compared to corresponding Fortran or C implementations. To achieve high performance, Java applications must be designed with good performance as a primary goal. This paper presents the object-oriented design and implementation of two real-world applications from the field of computational fluid dynamics (CFD): a finite-volume fluid flow solver (LAURA, from NASA Langley Research Center) and an unstructured mesh adaptation algorithm (2D_TAG, from NASA Ames Research Center). This work builds on our previous experience with the design of high-performance numerical libraries in Java. We examine the performance of the applications using the currently available Java infrastructure and show that the Java version of the flow solver LAURA performs almost within a factor of 2 of the original procedural version. Our Java version of the mesh adaptation algorithm 2D_TAG performs within a factor of 1.5 of its original procedural version on certain platforms. Our results demonstrate that object-oriented software design principles are not necessarily inimical to high performance. Copyright © 2003 John Wiley & Sons, Ltd. | |||||||||
| Publisher | John Wiley Sons, Ltd. Chichester, UK | ||||||||
| Category | Research Article | ||||||||
| Article Title | Java Virtual Machine support for object serialization | ||||||||
| Volume ID | 15 | ||||||||
| Issue ID | 3-5 | ||||||||
| Date | March 1 2003 | ||||||||
| DOI(URI) | http://dx.doi.org/10.1002/cpe.667 | ||||||||
| Article ID | CPE667 | ||||||||
| Author Name(s) | Fabian Breg1Constantine D. Polychronopoulos2 | ||||||||
| Author Email(s) | breg@csrd.uiuc.edu1 | ||||||||
| Affiliation(s) | University of Illinois, Coordinated Science Laboratory, room 444, 1308 W. Main Street, Urbana, IL 61 1 2 | ||||||||
| Keyword(s) | Java, object serialization, | ||||||||
Abstract |
|||||||||
| Distributed computing has become increasingly popular in the high-performance community. Java's remote method invocation (RMI) provides a simple, yet powerful method for implementing parallel algorithms. The performance of RMI has been less than adequate, however, and object serialization is often identified as a major performance inhibitor. We believe that object serialization is best performed in the Java Virtual Machine (JVM), where information regarding object layout and hardware communication resources are readily available. We implement a subset of Java's object serialization protocol in native code, using the Java Native Interface (JNI) and JVM internals. Experiments show that our approach is up to eight times faster than Java's original object serialization protocol for array objects. Also, for linked data structures our approach obtains a moderate speedup and better scalability. Evaluation of our object serialization implementation in an RMI framework indicates that a higher throughput can be obtained. Parallel applications, written using RMI, obtain better speedups and scalability when this more efficient object serialization is used. Copyright © 2003 John Wiley & Sons, Ltd. | |||||||||
| Publisher | John Wiley Sons, Ltd. Chichester, UK | ||||||||
| Category | Research Article | ||||||||
| Article Title | Automatic translation of Fortran to JVM bytecode | ||||||||
| Volume ID | 15 | ||||||||
| Issue ID | 3-5 | ||||||||
| Date | March 1 2003 | ||||||||
| DOI(URI) | http://dx.doi.org/10.1002/cpe.657 | ||||||||
| Article ID | CPE657 | ||||||||
| Author Name(s) | Keith Seymour1Jack Dongarra2 | ||||||||
| Author Email(s) | seymour@cs.utk.edu1 | ||||||||
| Affiliation(s) | Department of Computer Science, University of Tennessee, Knoxville, Knoxville, TN 37996, U.S.A. 1 2 | ||||||||
| Keyword(s) | Fortran, Java, JVM, bytecode, numerical libraries, | ||||||||
Abstract |
|||||||||
| This paper reports on the design of a Fortran-to-Java translator whose target language is the instruction set of the Java Virtual Machine. The goal of the translator is to generate Java implementations of legacy Fortran numerical codes in a consistent and reliable fashion. The benefits of directly generating bytecode are twofold. First, compared with generating Java source code, it provides a much more straightforward and efficient mechanism for translating Fortran GOTO statements. Second, it provides a framework for pursuing various compiler optimizations, which could be beneficial not only to our project, but to the Java community as a whole. Copyright © 2003 John Wiley & Sons, Ltd. | |||||||||
| Publisher | John Wiley Sons, Ltd. Chichester, UK | ||||||||
| Category | Research Article | ||||||||
| Article Title | Benchmarking Java against C and Fortran for scientific applications | ||||||||
| Volume ID | 15 | ||||||||
| Issue ID | 3-5 | ||||||||
| Date | March 1 2003 | ||||||||
| DOI(URI) | http://dx.doi.org/10.1002/cpe.658 | ||||||||
| Article ID | CPE568 | ||||||||
| Author Name(s) | J. M. Bull1L. A. Smith2L. Pottage3R. Freeman4 | ||||||||
| Author Email(s) | markb@epcc.ed.ac.uk1 | ||||||||
| Affiliation(s) | Edinburgh Parallel Computer Centre, James Clerk Maxwell Building, The King's Buildings, The University of Edinburgh, Mayfield Road, Edinburgh EH9 3JZ, U.K. 1 2 3 4 | ||||||||
| Keyword(s) | Java, C, performance, benchmarking, scientific applications, | ||||||||
Abstract |
|||||||||
| Increasing interest is being shown in the use of Java for scientific applications. The Java Grande benchmark suite was designed with such applications primarily in mind. The perceived lack of performance of Java still deters many potential users, despite recent advances in just-in-time and adaptive compilers. There are, however, few benchmark results available comparing Java to more traditional languages such as C and Fortran. To address this issue, a subset of the Java Grande benchmarks has been re-written in C and Fortran allowing direct performance comparisons between the three languages. The performance of a range of Java execution environments, C and Fortran compilers have been tested across a number of platforms using the suite. These demonstrate that on some platforms (notable Intel Pentium) the performance gap is now quite small. Copyright © 2003 John Wiley & Sons, Ltd. | |||||||||
| Publisher | John Wiley Sons, Ltd. Chichester, UK | ||||||||
| Category | Research Article | ||||||||
| Article Title | Run-time optimizations for a Java DSM implementation | ||||||||
| Volume ID | 15 | ||||||||
| Issue ID | 3 | ||||||||
| Date | March 1 2003 | ||||||||
| DOI(URI) | http://dx.doi.org/10.1002/cpe.660 | ||||||||
| Article ID | CPE660 | ||||||||
| Author Name(s) | R. Veldema1R. F. H. Hofman2R. A. F. Bhoedjang3H. E. Bal4 | ||||||||
| Author Email(s) | rveldema@cs.vu.nl1 | ||||||||
| Affiliation(s) | 1Department of Computer Science, Vrije Universiteit, Amsterdam, The Netherlands 1 2 Department of Computer Science, Cornell University, Ithaca, NY, USA 3 4 | ||||||||
| Keyword(s) | Java, DSM, compiler, runtime, protocols, | ||||||||
Abstract |
|||||||||
| Jackal is a fine-grained distributed shared memory implementation of the Java programming language. Jackal implements Java's memory model and allows multithreaded Java programs to run unmodified on distributed-memory systems. This paper focuses on Jackal's run-time system, which implements a multiple-writer, home-based consistency protocol. Protocol actions are triggered by software access checks that Jackal's compiler inserts before object and array references. To reduce access-check overhead, the compiler exploits source-level information and performs extensive static analysis to optimize, lift, and remove access checks. We describe optimizations for Jackal's run-time system, which mainly consists of discovering opportunities to dispense with flushing of cached data. We give performance results for different run-time optimizations, and compare their impact with the impact of one compiler optimization. We find that our run-time optimizations are necessary for good Jackal performance, but only in conjunction with the Jackal compiler optimizations described by Veldema et al. As a yardstick, we compare the performance of Java applications run on Jackal with the performance of equivalent applications that use a fast implementation of Java's Remote Method Invocation instead of shared memory. Copyright © 2003 John Wiley & Sons, Ltd. |
|||||||||
| Publisher | John Wiley Sons, Ltd. Chichester, UK | ||||||||
| Category | Research Article | ||||||||
| Article Title | Supporting multidimensional arrays in Java | ||||||||
| Volume ID | 15 | ||||||||
| Issue ID | 3-5 | ||||||||
| Date | March 1 2003 | ||||||||
| DOI(URI) | http://dx.doi.org/10.1002/cpe.661 | ||||||||
| Article ID | CPE661 | ||||||||
| Author Name(s) | José E. Moreira1Samuel P. Midkiff2Manish Gupta3 | ||||||||
| Author Email(s) | jmoreira@us.ibm.com1 | ||||||||
| Affiliation(s) | IBM T. J. Watson Research Center, Yorktown Heights, NY 10598-0218, U.S.A. 1 2 3 | ||||||||
| Keyword(s) | Java, high-performance computing, compiler optimizations, multidimensional arrays, | ||||||||
Abstract |
|||||||||
| The lack of direct support for multidimensional arrays in JavaTM has been recognized as a major deficiency in the language's applicability to numerical computing. It has been shown that, when augmented with multidimensional arrays, Java can achieve very high-performance for numerical computing through the use of compiler techniques and efficient implementations of aggregate array operations. Three approaches have been discussed in the literature for extending Java with support for multidimensional arrays: class libraries that implement these structures; extending the Java language with new syntactic constructs for multidimensional arrays that are directly translated to bytecode; and relying on the Java Virtual Machine to recognize those arrays of arrays that are being used to simulate multidimensional arrays. This paper presents a balanced presentation of the pros and cons of each technique in the areas of functionality, language and virtual machine impact, implementation effort, and effect on performance. We show that the best choice depends on the relative importance attached to the different metrics, and thereby provide a common ground for a rational discussion and comparison of the techniques. Copyright © 2003 John Wiley & Sons, Ltd. | |||||||||
| Publisher | John Wiley Sons, Ltd. Chichester, UK |
| Category | Research Article |
| Article Title | CartaBlanca - a pure-Java, component-based systems simulation tool for coupled nonlinear physics on unstructured grids - an update |
| Volume ID | 15 |
| Issue ID | 3-5 |
| Date | March 1 2003 |
| DOI(URI) | http://dx.doi.org/10.1002/cpe.662 |