|CFP - ICS Java Tutorial, WkShop Java for Tech. Computing firstname.lastname@example.org (1999-04-29)|
|Date:||29 Apr 1999 00:46:34 -0400|
|Keywords:||conference, Java, CFP|
DEADLINE EXTENDED UNTIL MAY 9th, 1999!
TUTORIAL & WORKSHOP ON JAVA FOR HIGH-PERFORMANCE COMPUTING
In conjunction with the 1999 ACM Int. Conf. on Supercomputing
June 19 and 20, 1999,
ANNOUNCEMENT AND CALL FOR PAPERS
The High-Performance Java Workshop at ICS'99 will take place during June
19 and 20, 1999 in conjunction with ICS'99.
The first day is dedicated to two tutorials on Java programming,
compilation and system support. The tutorials will discuss several
optimization techniques that improve the performance of Java programs.
The second day consists of a workshop on Java for high-performance computing.
WORKSHOP ON JAVA FOR HIGH-PERFORMANCE COMPUTING
Workshop Co-Chairs: Manish Gupta, Sam Midkiff and Jose Moreira, IBM
Sid Chatterjee, University of North Carolina
Dennis Gannon, Indiana University
Vladimir Getov, University of Westminster
Milind Girkar, Intel
Mohammad Haghighat, Intel
Tim Lindholm, Sun Microsystems
Kathryn McKinley, University of Massachusetts at Armhest
Michael Philippsen, The University of Karlsruhe
Roldan Pozo, NIST
Vivek Sarkar, IBM
Authors interested in contributing to the workshop are invited
to submit manuscripts that report new technologies and
practical experience related to the use of Java for high-performance
computing. Topics of interest include but are not restricted to:
Parallel and distributed computing with Java
Numerical computing in Java
Compilation and optimization techniques for Java
Computationally intensive applications developed in Java
Use of Java in database and other server-oriented applications
Java frameworks and libraries for high-performance computing
Tools and techniques for developing high-performance applications in
Accepted papers will be published in a technical report of the workshop.
Authors are welcome to submit papers on work that has been submitted
Authors should submit an extended abstract absolutely not to exceed
3000 words (approximately 6 pages) by the deadline of 5/09.
The program committee will review each submission and select
papers based on relevance, originality, soundness and clarity.
Accepted papers will be presented at the conference and published in the
Workshop Proceedings. Final versions of the papers, for publication,
are due on 5/25.
Only electronic submission will be accepted. Please e-mail a Postscript
or PDF copy of your submission to the Workshop Co-Chair Jose Moreira
5/09: Deadline for submission of extended abstract
5/15: Notification to authors of results
5/25: Final version due
June 19, 1999
Java programming and JIT-Compilation of Java for Intel Architecture
Aart Bik, Milind Girkar, Mohammad Haghighat
Microcomputer Research Labs
Target audience: Java VM/JIT developers, application programmers.
Assumed background: Java language, compilation techniques
Part 1: Java programming
length : 1 hour
what is Java, history of Java, comparisons with C/C++,
sample programs, development environment.
basic types, strings, arrays, objects, statements,
operators, classes, packages, input/output, variables,
virtual functions, superclass dependencies,
runtime class loading, interfaces.
error handling, throwable objects, catch or specify
requirement, finally clause, exception hierarchy.
thread context, priorities, synchronization, monitors,
wait and notify, thread states, examples.
Java virtual machine
architecture, registers, operand stack, instruction set,
garbage collection, verification
Applets, Graphics, Networking
Part 2: Java JIT-compilation
length : 3 hours
VM-JIT interaction, JIT-GC interaction, bytecode to IR translation,
IR to machine IR translation, code generation and formatting
CSE, loop invariant code motion, inlining, speculative
inlining, method specialization, multiversion code
Local/Global register allocation, instruction selection,
instruction scheduling, code/data alignment
Java specific Optimizations
Rangecheck elimination, checkcast/instanceof removal,
type propagation, optimizations enabled due to strong typing
Overview (Precise, imprecise, copying, generational, incremental),
analysis required for precise GC
String operations, supporting Intel MMX Technology
Supporting performance analysis tools
The Java model achieves security and platform independence by
translating and distributing applications in Java bytecodes, the
instructions of Java Virtual Machine. In the early releases of Java
Development Kit, bytecodes were interpreted by the JVM.
As Just-In-Time compilation technology has matured, JIT compilers
have now become integral parts of JVM implementations. By compiling
bytecodes into the host-machine instruction set and optimizing
the code on the fly, the performance of Java applications is
significantly improved, even matching the performance of
statically compiled languages. Given that compilation takes place
during the execution time of an application, JIT-compiler designers
are faced with a major challenge of identifying cost effective
optimizations and implementing them in an efficient manner.
In this tutorial, a team from Intel's Microcomputer Research Labs
that has developed a Java JIT-compiler for the Intel Architecture
presents their experiences and results. We start with an overview
of the Java language and the components of a Java environment.
We give detailed descriptions of Java constructs that have direct
impact on compilation. Covered topics include classes and objects,
interfaces, threads, exception handling, and garbage collection.
Next, we give a comprehensive and in-depth presentation about the
structure and optimizations of the state-of-the-art JIT-compiler that
we have developed. This includes JVM-JIT and JIT-GC interactions,
intermediate languages for translating bytecodes for Intel Architecture,
optimization techniques at various levels, exception handling,
and garbage collection. We further discuss a spectrum of high-level
optimizations such as CSE, loop-invariant code-motion, elimination of
range checks and cast checks, inlining, speculative inlining, method
specialization, multiversion code, optimizations enabled due to strong
typing, and hardware-assisted exception-handling. We also present the
techniques and heuristics that we used for low-level optimizations
such as local and global register allocation, instruction selection
and scheduling, and code and data alignment. Moreover, we share our
experiences with advanced vectorization techniques in support of
Intel's MMX Technology, as well as a demonstration of VTune, Intel's
performance analysis tool that assisted us in our optimizations design.
Static and Dynamic Optimized Compilation of Java programs
Vivek Sarkar and Manish Gupta
IBM T.J. Watson Research Center
Target Audience: Java VM and compiler developers.
Assumed Background: Java programming language, basic compiler
Length: 4 hours
Outline of the tutorial:
Part 1: Dynamic optimizations
length: 2 hours
Performance of Java programs, comparison with C/C++,
Java semantics and their impact on optimizations.
Alias analysis for Java:
Pointer-induced alias analysis for Java,
comparison with C/C++.
Optimizations from alias analysis:
Synchronization optimization and stack allocation
of heap data.
Optimization of methods with respect to the class
hierarchy, specialization of methods with respect to
data values, optimistic assumptions about exceptions,
recovery techniques for correctness of speculation.
Part 2: Static optimizations
length: 2 hours
Java applicability to numerical computing.
Exception model, absence of true multidimensional arrays,
no complex numbers, restricted floating-point semantics.
Techniques for high-performance numerical computing in Java:
Standard Array package, compiler techniques for creating
exception-free regions, semantic expansion, modified
In this tutorial, we describe the state of the art in optimized
compilation of Java programs. In the first half of the tutorial, we
discuss issues and techniques related to dynamic optimization of
general Java programs. As motivation, we show a breakdown of
execution time for some Java benchmark programs, and explain why these
Java programs run slower than comparable C/C++ programs. There are
several aspects of Java semantics that cause complications for
traditional optimizations e.g., exceptions, garbage collection,
threads, synchronization, and dynamic class loading. We describe
aggressive models of these semantics features that allow more code
motion and optimization to occur, compared to simpler models of these
features. On the positive side, the semantics of pointers (object
references) in Java is more restricted than the semantics of pointers
in C/C++ programs. We describe algorithms for pointer-induced alias
analysis for Java that are more precise and efficient than
corresponding algorithms for C/C++, and we discuss two key
optimizations for Java --- synchronization optimization and stack
allocation of heap data --- that use the results of pointer-induced
alias analysis. Finally, we briefly mention some speculative
optimizations that are well-suited to dynamic compilation
e.g., optimization of methods with respect to the (dynamic)
extant class hierarchy, specialization of methods with respect to
data values, and optimistic assumptions about exceptions.
We also outline recovery techniques that guarantee correctness when
speculative assumptions are violated.
In the second half of the tutorial, we discuss techniques for static
compilation and optimization of scientific programs written in Java.
The growing popularity of Java has led to a great deal of interest in
using it for numerically intensive computing, even though it was not
originally intended for applications in that domain. We describe the
important factors that inhibit performance of scientific programs
written in Java, like (i) precise exceptions and mandatory checks for
null pointers and out-of-bounds array access violations, (ii) absence
of true multidimensional arrays, (iii) lack of support for complex
data type, and (iv) restrictions in floating point semantics. We first
discuss the solutions that allow high performance, approaching the
levels of Fortran and C/C++, to be delivered without compromising on the
purity of Java. This is achieved through a combination of using class
libraries and a standard array package, and compiler techniques such
as creation of exception-free regions and semantic expansion of known
method calls. Each of these solutions is discussed in depth, with
supporting data based on performance measurements. We shall also
discuss proposals that seek to modify elements of the floating point
semantics of Java, in order to achieve higher performance.
Return to the
Search the comp.compilers archives again.