Subject: Last Reminder: ACM 1999 Java Grande Conference This Weekend

From: "Klaus E. Schauser" <[email-masked]>
Date: Thu, 10 Jun 1999 19:55:00 -0800

This is the last reminder to attend the ACM 1999 Java Grande 
Conference this weekend (June 12-14) in San Francisco. 
The conference is followed by a day of tutorials.  
More information (including all of the papers) is available 
on-line at  
    http://www.cs.ucsb.edu/conferences/java99

-------------------------------------------------------------------- 

                 ACM 1999 Java Grande Conference

(formerly ACM Workshop on Java for High-Performance Network Computing)
                
                  Sponsored by ACM SIGPLAN

        Student Participation Supported by NSF and DARPA

           San Francisco, California, June 12-14, 1999 

            http://www.cs.ucsb.edu/conferences/java99 

The Java Grande conference focuses on the use of Java in the broad
area of high-performance computing; including engineering and 
scientific applications, simulations, data-intensive applications, 
and other emerging application areas that exploit parallel and 
distributed computing or combine communication and computing.  
The conference includes a day of tutorials and will be followed by 
the JavaOne conference, which would enable people to follow the 
Java Grande conference with an exposure to the latest in basic 
Java Technology. 

Many interesting talks, papers, and posters, including invited talks 
by Bill Joy (Sun), Donald F. Ferguson (IBM) and Matt Welsh (Berkeley).

-------------------------------------------------------------------- 

   ACM 1999 Java Grande Conference Registration Form
     San Francisco, California, June 12-14, 1999 

It is important for planing of catering to obtain a precise estimate of 
attendees. Even if you can't pre-register now, please let us know if you 
intend to participate. E-mail your name, affiliation, and dietary needs 
to [email-masked]. 

Name (title, first, last): _________________________________________

Name tag should read: ______________________________________________

Affiliation: _______________________________________________________

Address: ___________________________________________________________

____________________________________________________________________

Phone: _____________________________________________________________

Fax: _______________________________________________________________

E-mail: ____________________________________________________________

Special needs (including dietary): _________________________________

Please mark selections with X:

CONFERENCE (June 12&13, 1999)
                        EARLY        LATE (after May 15 1999) 
  ACM member            $190 ___     $220 ___
  Non-Member            $220 ___     $250 ___
  Full-Time Student      $60 ___      $60 ___

  ACM membership number: ______________________

TUTORIALS (June 14, 1999)
  1. Java Based Mobile Code, Walker & Rana         (morning)    $75 ___
  2. JIT Compilation, Bik, Girkar & Haghighat      (afternoon)  $75 ___
  3. Java in Computational Science, Haupt & Fox    (morning)    $75 ___
  4. Java in Collaboration, Podgorny & Fox         (afternoon)  $75 ___
  5. Java Concurrency, Thiruvathukal & Christopher (full day)  $150 ___

TOTAL FEE (Conference & Tutorials): US$ ______

  Fees must be paid in U.S. dollars.  Please mark method of payment:

  Check (from U.S. bank, made payable to ACM Java'99) __  Money Order __

  Credit Card:  Visa __  MasterCard __

  Credit Card Number: ______________________ Expiration Date: _______

  Signature: ____________________________ Date: _____________________

Please complete and return this form with your remittance to:

       Klaus Schauser
       Attn: ACM Java Grande'99 Conference Registration
       Department of Computer Science
       University of California at Santa Barbara
       Santa Barbara, CA 93106
       USA

       E-mail: [email-masked]
       Phone: (805) 893-4321
       FAX:   (805) 893-8553 

-------------------------------------------------------------------- 

         ACM 1999 Java Grande Conference 

              ADVANCE PROGRAM

Saturday, June 12, 1999

     8:30am - 8:35am: Welcome - Geoffrey Fox, Klaus Schauser, and
     Marc Snir

     8:35am - 9:30am: Invited Talk

          Performance, Availability and Scalability for Enterprise
          Java Applications 
          Donald F. Ferguson 
          IBM T.J. Watson Research Center 

     9:30am - 10:45am: Session (1) -- chair Marc Snir

          The Gateway System: Uniform Web Based Access to
          Remote Resources 
          Tomasz Haupt, Erol Akarsu, Geoffrey Fox, Alexey
          Kalinichenko, Kang-Seok Kim, Praveen Sheethalnath and
          Choon-Han Youn 
          NPAC at Syracuse University 
   
          Wide-area Parallel Computing in Java 
          Rob van Nieuwpoort, Jason Maassen, Henri E. Bal, Thilo
          Kielmann and Ronald Veldema 
          Vrije University 
    
          Ajents: Towards an Environment for Parallel, Distributed
          and Mobile Java Applications 
          Matthew Izatt, Patrick Chan and Tim Brecht 
          York University and University of Waterloo 

     10:45am - 11:15am: Coffee Break

     11:15am - 12:30am: Session (2) -- chair David Tarditi

          Practical Guideline for Boosting Java Server Performance 
          Reinhard Klemm 
          Bell Laboratories 
     
          Performance Limitations of the Java Core Libraries 
          Allan Heydon and Marc Najork 
          Compaq Systems Research Center 
     
          Performance Measurement of Dynamically Compiled Java
          Executions 
          Tia Newhall and Barton P. Miller 
          University of Wisconsin Madison 

     12:30am - 2:00pm: Lunch

     2:00pm - 3:15pm: Session (3) -- chair Michael Philippsen

          Interfacing Java with the Virtual Interface Architecture 
          Chi-Chao Chang and Thorsten von Eicken 
          Cornell University 
     
          Design Issues for Efficient Implementation of MPI in Java 
          Glenn Judd, Mark Clement, Quinn Snell and Vladimir Getov 
          Brigham Young University and University of Westminster 
     
          Object Serialization for Marshalling Data in a Java
          Interface to MPI 
          Bryan Carpenter, Geoffrey Fox, Sung Hoon Ko and Sang Lim 
          NPAC at Syracuse University 

     3:15am - 3:45am: Coffee Break

     3:45pm - 4:35pm: Session (4) -- chair Shah Datardina

          Analysis and Development of Java Grande Benchmarks 
          J. A. Mathew, P. D. Coddington and K. A. Hawick 
          University of Adelaide 
    
          A Methodology for Benchmarking Java Grande Applications 
          J. M. Bull, L. A. Smith, M. D. Westhead, D. S. Henty and R. A.
          Davey 
          The University of Edinburgh 

     4:35pm - 6:30pm: Poster Session

          Design and Implementation of a Java(TM) Virtual
          Machine for Transactional Servers 
          Rajesh Bordawekar and Donna Dillenberger 
          IBM T.J. Watson Research Center 

          SciMark 2: a new interactive benchmark for scientific
          computing in Java 
          Roldan Pozo and Bruce Miller 
          National Institute of Standards and Technology (NIST) 

          LaTTe and VLaTTe: Java VM Just-in-Time Compilers for
          RISCs and VLIWs 
          ByungSun Yang, SooMook Moon, Seongbae Park, Kemal
          Ebcioglu, Junpyo Lee, SeungIl Lee, Jinpyo Park, Erik Altman,
          Yoo C. Chung, Suhyun Kim, and Heungbok Lee 
          Seoul National University and IBM T. J. Watson Research
          Center 

          Extending Java Virtual Machine to Improve Performance
          of Dynamically-Typed Languages 
          Yutaka Oiwa, Kenjiro Taura and Akinori Yonezawa 
          University of Tokyo 

          A Java/CORBA Based Visual Program Composition Environment 
          Matthew Shields, David Walker, Omer Rana and David Golby 
          Cardiff University and British Aerospace 

          ByteCode Specialization (BCS): A run-time specialization
          technique in JVM bytecode 
          Hidehiko Masuhara 
          University of Tokyo 

          Legacy to the Future Framework Design 
          James E. George and Denise C. George 
          Los Alamos National Laboratory 

          A Java Implementation for a New Load Balancing Strategy
          Ranjan Kumar Sen and Pradip Peter Dey 
          Hampton University 

          Annotating Java Class Files for Performance 
          Joel Jones and Samuel Kamin 
          University of Illinois at Urbana-Champaign 

          Profiling Java Programs via High-Resolution Timing
          Measurements 
          Nathan M. Hanish and William Cohen 
          University of Alabama in Huntsville 

          Traveler: A Mobile Agent Infrastructure for Wide Area
          Parallel Computing 
          Brian Wims and Cheng-Zhong Xu 
          Wayne State University 

          An Event-Based Approach using TSpaces for Composing
          Scalable Services 
          Michelle Munson 
          IBM Almaden Research Center 

          DISCWorld - A Java-Based Metacomputing Environment 
          K.A.Hawick, H.A. James and J.A.Mathew 
          University of Adelaide 

          Complex Numbers in Java 
          John Brophy 
          Visual Numerics 

          Java Array Classes 
          David S. Dixon 
          Least Squares Software 

          Java Lapack Objects 
          William N. Reynolds 
          Least Squares Software 

          Enhancing the Runtime Performance of a Java-based
          Distributed System 
          Jerry James and Ambuj K. Singh 
          University of California at Santa Barbara 

          Benchmarking Java on the IBM SP2 
          Mary Thomas, Vladimir Getov, Matthew Williams and Roger
          Whitney 

          Bayanihan BSP: An Adaptively Parallel and Fault-Tolerant
          Message-Passing API for Java-based Volunteer
          Computing Systems 
          Luis F. G. Sarmenta 
          MIT 

     7:00pm: Dinner (Sponsored by IBM and SUN)

          Play Safe, Go Fast: Using Java to Improve Performance 
          Matt Welsh 
          University of California, Berkeley 

Sunday, June 13, 1999

     9:00am - 10:15am: Session (5) -- chair Siddhartha Chatterjee

          Fixing the Java Memory Model 
          William Pugh 
          University of Maryland, College Park 
     
          A Tale of Two Directories: Implementing Distributed
          Shared Objects in Java 
          Maurice P. Herlihy and Michael P. Warres 
          Brown University 
    
          Efficient Support for Complex Numbers in Java 
          Peng Wu, Sam Midkiff, Jose Moreira and Manish Gupta 
          University of Illinois at Urbana-Champaign and IBM T.J. Watson
          Research Center     

     10:15am - 10:45am: Coffee Break

     10:45am - 12:00am: Session (6) -- chair Piyush Mehotra

          Design, Implementation, and Evaluation of Optimizations in
          a Just-In-Time Compiler 
          Kazuaki Ishizaki, Motohiro Kawahito, Toshiaki Yasue, Mikio
          Takeuchi, Takeshi Ogasawara, Toshio Suganuma, Tamiya
          Onodera, Hideaki Komatsu and Toshio Nakatani 
          IBM Tokyo Research Laboratory 
    
          The Jalapeno Dynamic Optimizing Compiler for Java 
          Michael G. Burke, Jong-Deok Choi, Stephen Fink, David
          Grove, Michael Hind, Vivek Sarkar, Mauricio J. Serrano, V. C.
          Sreedhar, Harini Srinivasan and John Whaley 
          IBM T.J. Watson Research Center and MIT 
     
          Java Annotation-aware Just-in-Time (AJIT) Compilation
          System 
          Ana Azevedo, Alex Nicolau and Joe Hummel 
          University of California, Irvine and University of Illinois, Chicago 

     12:00am - 1:30pm: Lunch

     1:30pm - 2:45pm: Session (7) -- chair Ron Boisvert

          A More Efficient RMI for Java 
          Christian Nester, Michael Philippsen and Bernhard Haumacher 
          University of Karlsruhe 
     
          Transparent Communication for Distributed Objects in Java 
          Michael Hicks, Suresh Jagannathan, Richard Kelsey, Jonathan T.
          Moore and Christian Ungureanu 
          NEC Research Institute and University of Pennsylvania 
     
          Javelin++: Scalability Issues in Global Computing 
          Sean P. Brydon, Paul Kmiec, Michael O. Neary, Sami Rollins
          and Peter Cappello 
          University of California, Santa Barbara      

     2:45pm - 3:45pm: Invited Talk

          Java: Towards a Science of Reliable Programming 
          Bill Joy 
          Sun Microsystems 

     3:45am - 4:15pm: Coffee Break

     4:15pm - 6:00pm: Java Grande Panel - Chair Geoffrey Fox

Monday, June 14, 1999

Tutorial 1: Mobile Agents -- Java based mobile code for 
            scientific applications
            David Walker and Omer Rana
            University of Wales

Tutorial 2: JIT Compilation of Java for Intel Architecture
            Aart J.C. Bik, Milind Girkar, and Mohammad R. Haghighat
            Intel Corporation

Tutorial 3: Use of Java in Computational Science
            T. Haupt and G. Fox
            Syracuse University

Tutorial 4: Use of Java in Collaboration and its integration 
            with JavaScript and Dynamic HTML
            M. Podgorny and G. Fox
            Syracuse University

Tutorial 5: Introduction to High Performance Java Computing:
            Abstractions for Concurrent, Parallel, and 
            Distributed Coordination using Java Threads
            George K. Thiruvathukal and Thomas W. Christopher
            Loyola University and Illinois Institute of Technology

-------------------------------------------------------------------- 

  Tutorial 1: Mobile Agents -- Java based
  mobile code for scientific applications

 Monday, June 14, 1999, 8:30am-12:30pm (half-day, morning)

             David Walker and Omer Rana

                  University of Wales

As distributed systems get more complex and deal with increasing
quantities of data, newer and sophisticated methods for information
search and retrieval are needed. Traditional methods for information
processing has required the data to be moved from the data source
to the point of processing. An approach gaining favour recently is
the concept of moving the computation to the data, in the form of
mobile code, that is generally referred to as a ``mobile agent''. This
is particularly beneficial when dealing with large data sets, or when
the exact sequence of service provision is not known in advance and
dependent on the order in which processing is performed. Hence, in
a system involving mobile agents, the agent can visit a number of
hosts, which offer part of the complete service required by the
agent. The agent does not need to know the complete itinerary in
advance, and may change its routing tables based on information
gathered at intermediate sites. This gives mobile agents the
autonomy to make decisions based on interactions with local hosts
as they move from one site to another, and negotiate services with
hosts as they travel across a communication network. Furthermore,
the mobile agent does not need a permanent connection to the
originating host, making it ideal for handling temporary network
connections, as available on numerous mobile devices. 

Approaches such as Remote Procedure Call (RPC) have generally
been the most common mechanism employed in distributed system
for calling services offered at a remote location. RPC makes the
calling of remote procedures the same as calling local procedures,
by offering local stubs for services available on a remote host. The
sender would call a local procedure stub with the appropriate
arguments, which would then be packed as a message, encoded,
and sent to the remote site, where a reverse sequence of events
would take place. The required service would be executed and a
response sent back to the sender. The main characteristic of such a
process is that each remote call between the requester and the
provider entails two communications, one to ask for the service, and
the other to acknowledge that the service was accepted. 

The alternative approach of Remote Programming (RP), as
employed in mobile agents, views the interaction between the client
requesting the service and the server providing it, as not only a
calling of a procedure with the necessary arguments, but also
supplying the code for procedures which are to be performed
remotely. Each message sent between the client requesting service
on another computer in the RP model, would involve the sending of
code which specifies the procedures to run, and data which holds
the current state of the interaction. 

In this tutorial we compare and contrast thread based code
migration with agent based remote programming. We look at the
differences between mobile agents and CORBA based services,
and identify areas of overlap between the two approaches. We look
at the Java based ``Aglets'' mobile agents library, from IBM
Research (Japan), and show how it may be combined with
Java-MPI. 

Presenters:

Professor David Walker is head of the Parallel and Scientific
Computing group in the Department of Computer Science at the
University of Wales Cardiff, UK. He has conducted research into
parallel software for scientific computation for the past 13 years, the
first ten years of which were spent in the United States, and has
published over 60 papers on the subject. Professor Walker teaches
various courses on parallel computing and algorithms to
undergraduate and postgraduate students. He has also been actively
involved in special interest groups in parallel computing and high
performance Java. 

Dr. Omer Rana is an assistant professor at the Department of
Computer Science at the University of Wales Cardiff, UK. He has
been actively involved in the public understanding of science,
working with BBC radio and television, Channel 4 and the
Discovery Channel as part of ScienceLine. He has been a visiting
research fellow to BT Labs, where he has worked with Aglets for
implementing parallel data mining applications in telecommunications.
He teaches distributed computing and multi-agent systems to both
undergraduates and postgraduates, and has also presented these
courses to local companies, such as BT, Nortel and Hyder. He has
also been actively involved in special interest groups in high
performance Java. 

Benefits to participants:

The participants will gain an insight into the use of mobile agents with
conventional parallel computing libraries, such as MPI. The
difference between thread mobility, active messages and mobile
agents will be highlighted using a data mining algorithm. Extensions
to other application domains will also be discussed, in particular load
balancing and automatic software configuration. The extension to
dynamic resource discovery, using KQML/KIF libraries, such as
JKQML from IBM Research will also be demonstrated, with
example programs. The use of KQML based messaging, built over
MPI, will be demonstrated for building a large society of agents,
some of which may be mobile. A brief overview of other application
areas will be provided towards the end of the tutorial, with reference
to Globus and DoD's HLA. 

 Tutorial 2: JIT Compilation of Java for Intel Architecture

  Monday, June 14, 1999, 1:30pm-5:30pm (half-day, afternoon)

 Aart J.C. Bik, Milind Girkar, and Mohammad R. Haghighat

             Microcomputer Research Labs
                   Intel Corporation

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 Intel Architecture
presents their experiences and results. We start with an overview of
the Java language and the components of a Java environment, and
give a comprehensive and in-depth presentation on the structure and
optimizations of this state-of-the-art JIT compiler. Covered issues
include 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. 

Presenters:

Aart J.C. Bik received his M.S. degree in computer science from
the Utrecht University, The Netherlands, in 1992. He received his
Ph.D. degree in 1996 from the Leiden University, The Netherlands.
He was a post doctoral research fellow at the Indiana University,
where he was involved in the design and implementation of a
high-performance Java system under supervision of Prof. D.B.
Gannon. Currently, he is a senior software engineer at Intel's
Microcomputer Research Labs. His research interests are in sparse
matrix computations, optimizing and parallelizing compilers and Java.
His email address is [email-masked]. 

Milind Girkar did his PhD at the University of Illinois at
Urbana-Champaign. Currently, he is a senior software engineer in
Intel's Microcomputer Research Labs. Prior to Intel, he worked on
the compiler for the UltraSparc architecture at Sun. His research
interests are in parallelizing and optimizing compilers. His email
address is [email-masked]. 

Mohammad R. Haghighat is a senior software engineer at Intel's
Microcomputer Research Labs. His research interests are in
optimizing and parallelizing compilers and multithreaded
architectures. He holds a B.S. in Computer Science and Engineering
from Shiraz University, and an M.S. and a Ph.D. in Computer
Science from the University of Illinois at Urbana-Champaign.
Mohammad is the author of a book on symbolic analysis for
parallelizing compilers. His email address is
[email-masked]. 

          Tutorial 3: Use of Java in Computational Science

 Monday, June 14, 1999, 8:30am-12:30pm (half-day, morning)

                 T. Haupt and G. Fox

                  Syracuse University

This tutorial assumes a basic familiarity with Java the Language and
describes frameworks and applications useful in different areas of
computational science 

Java can be used in many aspects of engineering and scientific
computing including user interfaces, servers to provide web hosting
of resources and as a basic coding language. We describe these
different aspects describing where Java can be used today and
where it still has performance or functionality disadvantages. In the
computing arena, we discuss both sequential and parallel computing.
We also discuss the use of Java as an educational tool for building
novel interactive learning sites. 

We review status of Java Grande and its initiatives aimed at
providing in Java the best possible programming environment. We
describe the role of Java and distributed objects in middleware;
specialized capabilities such as matrix libraries; Java for visualization;
Java and MPI for parallel computing and Java in the building of
seamless interfaces and problem solving environments. We contrast
classic HPCC (High Performance Computing and Communication)
applications to those from distributed simulation. Using Java and
distributed objects provides a unified approach. 

This tutorial should be of interest to both computer scientists and
those application programmers interested in using Java in different
aspects of their research and education. 

Presenters:

Geoffrey Fox obtained his Undergraduate and Graduate degrees at
Cambridge University. Most of his professional career has been
spent at Caltech (Physics) and Syracuse University
(Physics/Computer Science). Fox is an expert in the use of parallel
architectures and the development of concurrent algorithms. He
leads a major project to develop prototype high performance Java
and Fortran compilers and their runtime support. His group has
pioneered use of CORBA and Java for both collaboration and
distributed computing and Fox helped initiate the international Java
Grande activity. Fox is a proponent for the development of
computational science and its follow on "Internetics" as an academic
discipline and a scientific method. He has established at Syracuse
University both graduate and undergraduate programs in these
areas. All courses have been made available on the Web and his
research includes HPCC technology to support education at both
K-12 and University level. His research on parallel computing has
focused on development and use of this technology to solve
large-scale computational problems -- such as numerical relativity
and earthquake prediction. A recent set of activities center on Web
collaboration technology and its application to synchronous distance
education. His email address is [email-masked]. 

Tomasz Haupt graduated from Jagiellonian University in Krakow
(Poland) and obtained his Ph.D. in Physics. For 10 years he was
involved in data analysis coming from numerous High Energy
(elementary particles) experiments at CERN and CESR (Cornell).
>From 1990 he has been at Syracuse University with initial activity as
development of the Fortran 90D compiler - the first data-parallel
flavor of Fortran targeted to distributed memory systems that soon
became the first, pilot implementation of HPF compiler. Later, the
technology developed by the Fortran 90d group was licensed to
PGI, Inc. In addition to developing the language (Haupt participated
in HPF forum), and developing the compiler including its runtime
support, Haupt's was involved in numerous activities to transfer the
new technologies to application developers. This includes his
participation in the Grand Challenge Binary Black Hole project.
Currently, Haupt's research activity concentrate on employing the
Web based technologies to high performance distributed computing.
Haupt is applying the WebFlow system to many different classes of
applications. These include development of a nanomaterials problem
solving environment (within NCSA Alliance), where WebFlow
provides a high level visual user interface. As part of the DoD high
performance computing modernization program, Haupt developed
the Landscape Management System that implements "navigate and
choose" paradigm to provide seamless access to remote data and
computational resources to solve the problem at hand. Currently he
is working on the Gateway system (under development for ASC) to
integrate application domain specific Problem Solving Environments
(PSE) with a seamless and secure remote access to resources
available at the ASC computer center. 

 Tutorial 4: Use of Java in Collaboration and its integration 
         with JavaScript and Dynamic HTML

  Monday, June 14, 1999, 1:30pm-5:30pm (half-day, afternoon)

                M. Podgorny and G. Fox

                  Syracuse University

We illustrate the value of integrating Java and JavaScript to build
collaborative systems built around synchronously shared web
objects (defined as any entity -- coming from a web server,
web-linked database or CGI script -- invoked by the user from
HTML). We describe the architecture and use of TangoInteractive
which can share web-objects as well as Java and C++ applications.
We do this in the context of a general framework of shared event
collaborative systems. We show the power of this system to provide
shared dynamical HTML and contrast the use of this with interactive
environments built around Java Applets. The application of this
technology to distance education with lessons from its use will be
given. We comment on implications of this type of application for the
proposed W3C Document Object Model at both XML and HTML
levels. We describe how collaborative technology naturally provides
universal interfaces accessible across disabilities. Shared web
objects are natural in many areas including engineering design,
valued added commerce and education. This tutorial should be of
interest either to those interested in these areas as well as developers
of Java and Dynamic HTML systems. 

Presenters:

Geoffrey Fox (see bio for Tutorial 3). 

Marek Podgorny has PhD in physics and a 18 years record of
research in solid state physics. Since 1991 he changed his research
interest to distributed computing and distributed information systems.
He has led several successful projects such as early deployment of
ATM-based wide area networks including a statewide activity
NYNET. He developed applications of parallel database systems in
data fusion processes, video on demand technology, Command and
Control network-centric solutions, and Web multimedia
collaborative and distance learning environments. The latter is his
major focus today with the TangoInteractive system being used in
several collaboration and distance education areas. Podgorny has
broad expertise in databases, web technologies including
sophisticated Java clients and servers, video and audio compression
and all aspects of networking. 

     Tutorial 5: Introduction to High Performance Java Computing:
  Abstractions for Concurrent, Parallel, and Distributed 
               Coordination using Java Threads

 Monday, June 14, 1999, 8:30am-12:30 1:30-5:30pm (full-day)

    George K. Thiruvathukal and Thomas W. Christopher

    Loyola University and Illinois Institute of Technology

This course provides an intermediate to advanced treatment of the
Java multithreading framework, which is included with all versions of
the Java Development Kit. This course is primarily aimed at industry
practitioners, technical staff, and scientists who are already familiar
with the ideas of concurrency and have some experience with
multithreading and multiprogramming in another language, such as C
or C++. 

Due to the length of this course and expected enrollment, it will not
be practical to provide hands-on experience; however, students will
be provided with notes and a CD containing working example
programs, reusable packages, and documentation. A longer version
of this course is available commercially (and to academics) from
Tools of Computing LLC. This course is also the subject of a
forthcoming book by the authors, tentatively scheduled for release
during 1Q2000. 

The following topics will be covered during this one day intensive,
subject to available time. 

Introduction to Multithreaded Programming: Know Your
Enemy 

This section provides a high-level overview of processes and
threads, the differences between the two, and a summary of general
operating system support for threads. Programming with processes
and threads continues to be an error prone activity, and this section
will detail the pitfalls of working with threads and motivate the need
for the rest of the course, where much time is spent on higher-level
approaches to concurrency. 

Classic Synchronization Mechanisms: Locks, Semaphores,
Conditions, Barriers 

Java objects support closely the notion of a monitor, as defined by
C.A.R. Hoare and P. Brinch Hansen. Programmers unfamiliar with
monitors often find the abstraction unwieldy and lacking the precise
control found in other synchronization mechanisms. This section will
be of great interest to those who have worked with Posix and
Win32 threads environments and parallel environments, where such
control is taken for granted. 

Concurrent Problems Revisited: Shared*, ProCon*,
Monitors*, Diners*, Readers/Writers* 

This section begins by introducing the notion of a race condition,
which remains a little understood troublemaker in concurrent
programming. A number of classic synchronization problems are
presented (fairly quickly) with exciting examples that have been
graphically animated to better teach the actual problem. We also
show how to apply these problems, which are often of purely
intellectual interest, to real world situations. 

Higher-Level Abstractions for Concurrent Programming:
Futures, Incremental Structures, FutureQueue, FutureTable 

Low-level synchronization mechanisms have a key disadvantage of
requiring good discipline to guard against race conditions and other
pitfalls. Programming bugs almost inevitably occur. As a first step
toward eliminating these problems, higher-level abstractions have
been proposed (some dating back almost 20 years in work on
functional programming) to express concurrent computations. This
section will introduce the notion of a future and show how to extend
Java's built-in Vector and Table classes to make use of futures. 

Applications Higher-Level Abstractions: Shared Table of
Queues, Macro-Dataflow, Task Graphs, Work Pools,
Concurrent Aggregates 

This final section applies the abstractions derived from futures to
provide some useful classes to hide most details (especially the
details that cause programming errors) of concurrent computing
from the programmer. A number of case studies are presented,
beginning with the notion of a shared table of queues (a key building
block for a tuple space), macro-dataflow (a version of dataflow that
supports coarse-grain parallelism), task graphs, work pools (a
convenient abstraction for distributed batch processing), and
concurrent aggregates (useful for parallel array and table
operations). 

Dr. Thomas Christopher is an Associate Professor of Computer
Science at Illinois Institute of Technology. He has over two decades
of experience as a teacher and researcher. Professor Christopher's
research interests are in the areas of programming languages and
distributed-memory parallel processing. In the
programming-language area, he is the author of several compilers
and parser generators. His most recent parser generator is a
Strong-LL(k) parser generator that transforms the LL(k) grammar
into an LL(1) grammar with back-up actions. In the parallel
processing area, he has designed and implemented a number of
parallel processing systems based on message-driven designs. The
most recent, in Java, passes active messages among the nodes
(distributed processes). The active messages themselves specify
code to be executed upon the arrival of the message at the
destination node. He also designed the Memo system that provides
inter node communication through a shared directory of queues. 

Dr. George K. Thiruvathukal is a Visiting Assistant Professor at
Loyola University in Chicago, Illinois. His doctoral dissertation was
entitled An Enhanced Actors Model and Programming Environment
for Parallel and Distributed Processing. Currently, he is a
co-director of the Java and High-Performance Research Group
(JHPC) and Secretary General of the Java Grande Forum. While at
the Argonne National Laboratory in the Mathematics and Computer
Science Division, he was a member of the Globus project where he
has worked on a wide-area implementation of the Message Passing
Interface (MPI), and Java-based visualization tools for
metacomputing systems. His current research is on a message
passing system called Active Java and a computational sharing
framework called the Computational Neighborhood. He recently
participated in the ACM Java '98 (held at Stanford University)
workshop, PDPTA 1998 and 1999, and IPPS/SPDP Workshop
on Java as a program committee member. Dr. Thiruvathukal has
also served as an Adjunct Associate Professor and Lecturer,
Computer Science, at I.I.T. from 1997-98. He has also held senior
technical staff and management industry positions at Tellabs and
R.R. Donnelley and Sons Companies from 1991-1995. 

-------------------------------------------------------------------- 
 Klaus E. Schauser                 E-mail: [email-masked] 
 Associate Professor               Phone: (805) 893-3926 
 Department of Computer Science           (805) 893-4321 
 University of California          FAX:   (805) 893-8553 
 Santa Barbara, CA 93106           http://www.cs.ucsb.edu/~schauser 
--------------------------------------------------------------------