Real-Time Java

Java Cá&Lá or just JCL is a distributed shared memory reflective lightweight middleware for Java developers whose main goals are: i) provide a simple deployment strategy, where automatic code registration occurs, ii) support a collaborative multi-developer cluster environment where applications can interact without explicit dependencies, iii) execute existing sequential Java code over both multi-core machines and cluster of multi-core machines without refactorings, enabling the separation of business logic from distribution issues in the development process, iv) provide a multi-core/multi-computer portable code. This paper describes JCL's features and architecture; compares and contrasts JCL to other Java based middleware systems, and reports performance measurements of JCL applications.

This paper describes JaDiMa (Java Distributed Machine), a collaborative framework to construct high performance distributed Java applications on grid platforms. JaDiMa is a system that automatically manages remote libraries used in a Java application. It leverages on the advantages of portability, modularity, object oriented model and flexibility of Java, while incorporating well known techniques of communication and security. JaDiMa allows users to compile and execute Java applications which use distributed libraries, without the need of keeping them in the developer and user hosts. The result is a simple and efficient distributed environment upon which applications and data are easily shared and highly portable amongst heterogeneous platforms and multiple users. We describe an implementation of JaDiMa as part of suma/g, a Globus-based grid environment. We also show experiences of executing an application, which uses libraries for managing graph and network data, on several scenarios with suma/g and JaDiMa.

Traditionally, parallel programs have been developed in Fortran and C. However, the extraordinary success of the Java language has raised an impressive hype among the community of software programmers, in such a way that it seems quite promising that parallel programmers could also use Java in their applications. In this paper, we describe the implementation of Java interface for WMPI, a Windows-based implementations of MPI that have been developed and supported by our group. We show some details about the implementation and we present some experimental results that compare the performance of Java WMPI, Java WPVM and the C programs counterparts.

SILK (Scheme in about 50 K) is a compact Scheme implementedin Java. It is currently in its fourth implementation.The rst version implemented a nearly R4RS Schemein Java, but its access to Java was awkward. The currentversion has altered SILK's syntax and semantics slightly tobetter integrate with Java. This has simplied its implementation,and made SILK an eective Java scripting language,while preserving

Srivastav et al already published several papers where the authors tried to explain the various aspects of object oriented language like Java using some simple mathematical model or functions. The authors have already studied the general properties of Java language such as object, class, inheritance, multithreaded concepts using simple mathematical concepts. In the present paper the authors have tried to explore the concept of exception handling in java language using discontinuity in a function. The exceptions are normally come during runtime and some of the exceptions are repairable and some may not be repairable. In the present paper the authors tried to explain both repairable exception and also irreparable exceptions by considering simple continuity and discontinuity in functions.

Java is one of the most demanding programming languages nowadays and it is used for developing a wide range of software applications including desktop, mobile, embedded, and web applications. Writing efficient Java codes for those various types of applications (which some are critical and time-sensitive) is crucial and recommended best practices that every Java developer should consider. To date, there is a lack of in-depth experimental studies in the literature that evaluate the impact of writing efficient Java programming strategies on the performance of desktop applications in terms of runtime. Thus, this paper aims to perform a variety of experimental tests that have been carefully chosen and implemented to evaluate the most important aspects of desktop efficient Java programming in terms of runtime. The results of this study show that significant performance improvements can be achieved by applying different programming strategies.

Java is quickly becoming the most popular platform for distributed computing. However, its performance is still subject to concerns in comparison to other programming languages such as C and Fortran. As a consequence, programmers of high-performance applications are usually reluctant to embrace Java as an alternative language in their work. This article introduces the Java-to-C Interface (JCI) tool which generates automatically the wrapper code interfacing existing scientific libraries to Java. Thus, facilitating rapid development and software reuse, the JCI tool provides application programmers with immediate accessibility to existing scientific libraries from Java. While beneficial to the software developer, the additional advantages of mixed-language programming in terms of application performance are addressed in detail within the context of this work. We also present analysis and comparisons of evaluation results for mixed-language codes in Java and C/Fortran on a high-performance distributed memory computer (IBM SP-2). The NAS Embarrassingly Parallel and Integer Sort benchmarks as well as the Matrix Multiplication kernel from the PARKBENCH suite were selected for our experiments. The evaluation results demonstrate the feasibility and efficiency of our mixed-language programming methodology with Java.

Java is quickly becoming the most popular platform for distributed computing. However, its performance is still subject to concerns in comparison to other programming languages such as C and Fortran. As a consequence, programmers of high-performance applications are usually reluctant to embrace Java as an alternative language in their work. This article introduces the Java-to-C Interface (JCI) tool which generates automatically the wrapper code interfacing existing scientific libraries to Java. Thus, facilitating rapid development and software reuse, the JCI tool provides application programmers with immediate accessibility to existing scientific libraries from Java. While beneficial to the software developer, the additional advantages of mixed-language programming in terms of application performance are addressed in detail within the context of this work. We also present analysis and comparisons of evaluation results for mixed-language codes in Java and C/Fortran on a high-performance distributed memory computer (IBM SP-2). The NAS Embarrassingly Parallel and Integer Sort benchmarks as well as the Matrix Multiplication kernel from the PARKBENCH suite were selected for our experiments. The evaluation results demonstrate the feasibility and efficiency of our mixed-language programming methodology with Java.

With most of today's fast scienti c software written in Fortran and C, Java has a lot of catching up to do. In this paper we discuss how new Java programs can capitalize on high-performance libraries for other languages. With the help of a tool we h a v e automatically created Java bindings for several standard libraries: MPI, BLAS, BLACS, PBLAS, ScaLAPACK. Performance results are presented for Java v ersions of two benchmarks from the NPB and PARKBENCH suites on an IBM SP2 distributedmemory machine using JDK and IBM's high-performance Java compiler. The results con rm that fast parallel computing in Java is indeed possible.

He made my PhD journey an excellent experience with his knowledge, kindness, thoughtfulness and encouragement. I would like to dedicate my deep thanks for my mother, for the encouragement she provided, her unlimited patience, prayers and the sacrifices she made to help me after my father passed away, which without, I would not be able to achieve my goals and survive difficult times. I am greatly indebted to my sincere wife Dalia and my daughter Julie, without their hopeful smiles, emotional support, patience, understanding and infinite love I would not have been able to stand during the difficult moments in my PhD. I would like to convey my sincerest gratitude to my uncle Wahid Hamza who has been supportive through all my life stages. His sympathy and understanding were enormous and significantly appreciated. I am very grateful to all people in the Department of Information Systems and Computing at Brunel University who helped me during my study and provided such a friendly and comfortable environment. Last, but by no means least, I would like to thank all my friends and colleagues who have been my other family in the UK.

Distributed Computing Systems allows concurrent execution of computational jobs besides offering other benefits. Object allocation is a natural requirement as both the hardware and the software adapt the object-oriented technology. In this paper, we elaborate how a distributed shared memory may facilitate in object allocation on object-oriented distributed computing systems.

Distributed Computing Systems allows concurrent execution of computational jobs besides offering other benefits. Object allocation is a natural requirement as both the hardware and the software adapt the object-oriented technology. In this paper, we elaborate how a distributed shared memory may facilitate in object allocation on object-oriented distributed computing systems.

¢¡ ¤£ ¦¥ ¨ § © ! #" $ % ¦ & ' (£ )' ¡ 0' 21 3 ) 54 3 5 ¦ § &¡ 76 5 &© 8" 9 § @£ ¦¥ 0A 21 7 B C B¡ ¨D fk l mD n ' § t¡ y£ ¦ 5 o© ¦ Bh p 5£ qe y 9 r p © (' )' 21 3£ ¦p § t¡ ¨ © (' x © ( § tx ¨p © c£ C B£ ¦ § 6 B¡ s ve 3¡ x § 6 6 C¥ 7 &6 Ct v© qh U' o6 &' ( ¦ 56 5£ o1 ¨© ¦ A r' Bh p ' !" qD np &r &p u' 2 C B£ ¦ § ' 2¡ ¨© & 7 B¡ 54 ¨ x § ¡ ¨ s¥ ¨' i" 06 &' v ¨ s6 &' 2¡ y£ C B § t¡ ¨ § ¡ 7A p t' !" qD p &r 2 &p v' 5 C B£ ¦ § ' ¡ 7© 96 ! ¡ %d H' 2 3£ ¦ § x § tj

The ESC/Java tool was a lauded advance in effective static checking of realistic Java programs, but has become out-ofdate with respect to Java and the Java Modeling Language (JML). The ESC/Java2 project, whose progress is described in this paper, builds on the final release of ESC/Java from DEC/SRC in several ways. It parses all of JML, thus can be used with the growing body of JML-annotated Java code; it has additional static checking capabilities; and it has been designed, constructed, and documented in such a way as to improve the tool's usability to both users and researchers. It is intended that ESC/Java2 be used for further research in, and larger-scale case studies of, annotation and verification, and for studies in programmer productivity that may result from its integration with other tools that work with JML and Java.

I am deeply grateful to my advisor Kathryn McKinley for guiding me through grad school with utmost interest and dedication. She was flexible enough to let me do what I wanted, even if it was outside her area. In the days before my first paper submission, she gave me undivided attention and worked through the night until we submitted the paper. At times it seemed like she cared more about my success and well-being than I did myself. I wouldn't have gotten this far without her unflinching positive attitude and encouragement. As I leave grad school, inspired by Kathryn as a researcher and a human being, I will strive to always give my best to those around me. Over the past three years, Michael Hicks' meticulous attitude towards research has been a positive influence. Always prompt to reply to e-mails, he invariably shot down most of my arguments and imparted some of his vast knowledge in the field of dynamic software updating. I thank him for all his advice and for introducing us to scrum for research [41]. Steve Blackburn has always been eager to offer technical advice and guidance. I thank Steve, Keshav Pingali, and Calvin Lin for their insightful questions and helpful feedback. My research has benefitted enormously from my interactions with Mike Bond. I thank him for brainstorming engaging research problems as well as for patiently answering technical questions. For their personal and technical support, I thank members of the Speedway research group:

It is indispensable to have time synchronization and event/pulse generation systems on board oceanographic research vessels to control the data acquisition rate of sensors and equipment. This paper presents a pulse generation system based on the aJ-100 real-time Java embedded system with the capability of being integrated into a general-purpose acquisition system of the BIO Hesperides research vessel named LabVir. In the development of this system, a platform with reduced size and weight and networking technology for system control and data access was used, making its integration easy in any research vessel. Furthermore, a logic design for the event generation was implemented, making the overall system adaptable to any future needs.

During the last few years, the concepts of cluster computing and heterogeneous networked systems have received increasing interest. The popularity of using Java for developing parallel and distributed applications that run on heterogeneous distributed systems has also grown rapidly. This paper is a survey of the current projects in parallel and distributed Java. These projects' main common objective is to utilize the available heterogeneous systems to provide high performance computing using Java. These projects were studied, compared and classified based on the approaches used. The study shows three major approaches. One is to develop a system that replaces the Java virtual machine (JVM) or utilizes the available parallel infrastructure such as MPI or PVM. Another is to provide seamless parallelization of multi-threaded applications. The third is to provide a pure Java implementation by adding classes and features that support parallel Java programming. In addition, a number of open issues are

Сопутствующее обнаружение ошибок в распределённых системах: практическое исследование. Обнаружение ошибок определено как наблюдение за работой системы, чтобы удостовериться в соответствии её функционирования с ожидаемым поведением. Согласно стандартам IEEE, обнаружение ошибок — одно из средств достижения отказоустойчивости. Следовательно, обнаружение ошибок — необходимая часть процесса разработки чувствительных к отказам систем. Сопутствующее обнаружение ошибок в распределённых системах — одна из проблем, исследуемых в рамках совместного проекта S3ARV (Small & Safe Space Autonomous Robotic Vehicles) IfA, TU Dresden и iFR, Uni Stuttgart. В представленной статье авторы вводят новый фреймворк обеспечения безопасности, основанный на сопутствующем обнаружении ошибок. Наш подход направлен на наблюдение за распределённым управляющим программным обеспечением реального времени. Прототип фреймворка применён на летательном аппарате (октокоптере).

Structure  Threads or event handling  Why JSR 302 decided to use event handlers  The JSR 302 concurrency model  Known inconsistencies in the model  Revised model  Conclusions Concurrency Models: Threads  Support standardised across OSs  Supported in most real-time languages  Well established and problems well understood  real-time scheduling  priority inversion control  deadlocks (if use locks)  composability and scalability

Java is receiving increasing attention as the most popular platform for distributed computing. However, programmers are still reluctant to embrace Java as a tool for writing scientific and engineering applications due to its still noticeable performance drawbacks compared with other programming languages such as Fortran or C. In this paper, we present a hybrid Java/Fortran implementation of a parallel particle-in-cell (PIC) algorithm for plasma simulations. In our approach, the time-consuming components of this application are designed and implemented as Fortran subroutines, while less calculation-intensive components usually involved in building the user interface are written in Java. The two types of software modules have been glued together using the Java native interface (JNI). Our mixed-language PIC code was tested and its performance compared with pure Java and Fortran versions of the same algorithm on a Sun E6500 SMP system and a Linux cluster of Pentium~III machines.

\Grande" applications are those with demanding CPU and I/O requirements. They originate in many disciplines, such as astrophysics, materials science, weather prediction nancial modeling, and data mining. Java has many features of interest to developers of such applications. At the same time, there are currently many barriers to the e ective use of Java i n t h i s w ay. The Java Grande Forum is a group of researchers and software developers from industry, academia, and government w i t h a n i n terest in the use of the Java programming language and environment for grande applications. The Forum seeks to increase awareness of issues important to this community, and to work towards their solution. In this article we describe the workings of the Java Grande Forum and the major issues that it has brought to the forefront. We o u tline approaches to the solutions of these problems, and describe e orts to standardize them within the larger Java community. Among the issues addressed are: oating-point performance, multidimensional arrays, complex arithmetic, fast object serializations, and high-speed remote method invocation (RMI). Java programmers do not need to explicitly deallocate blocks of memory. Instead, Java m a i n tains a garbage collector which automatically recovers unused storage. The safety o f J a va is enhanced by the absence of arbitrary pointers, and by t h e requirement that all array bounds be checked before access. Because of such features, Java i s n o w widely used both in commercial software development, in research, and as an educational tool in universities. Indeed, computer science departments everywhere seem to be switching to Java a s t h e main language they teach their students. This, as much a s e v erything else, will assure Java's place in software development for some time to come. While Java h a s made great inroads in a v ariety o f areas, it is far from the language of choice for \grande" applications, i.e., those with the most demanding CPU and I/O requirements. (The term \grande", like many things associated with Java, is inspired by co ee house jargon, where grande means large.) They originate in many disciplines, such as astrophysics, materials science, weather prediction, nancial modeling, and data mining. However, system requirements for modern grande applications go far beyond mere compute cycles. Communication with distributed components in a heterogeneous environment m ust be maintained. Graphical user interfaces must be developed. High levels of portability m ust be maintained to insulate the application from changes in the underlying hardware and software platform. Java is the rst single environment t o p r o vide all of these features. Nevertheless, when Java is found in grande contexts today i t i s t ypically being used as glue, interconnecting existing high-performance applications, linking computations realized in other languages to one another, and acting as a layer between computations and the user. This a a perfectly reasonable use of Java today. H o wever, the bene ts of portability a orded by J a va cannot be realized unless the entire application is run in a Java e n vironment. Why isn't Java commonly used for the compute-or I/O-intensive core of grande applications? The main reason is undoubtedly performance. In its early days JVMs were strictly interpreters, resulting in very poor performance. In the science and engineering community J a va has not shaken this early perception. Today nearly every JVM for traditional computing devices uses just-in-time (JIT) compiler technology. JITs operate as part of the JVM they compile Java class les into native code at runtime, thus providing a much higher level of performance than interpreted code. Since JITs operate at runtime, they cannot expend a lot of time performing extensive analysis of class le code looking for optimizations. Nevertheless, JITs have been improving steadily, and JIT technologies such as Sun's Hotspot ], which only compiles those portions of the code it deems necessary to improve performance, promise even greater strides forward. Still, some of Java's features, while kind to programmers, can be performance reducers, and thus sore points for those developing grande applications. Things like overactive garbage collection and unoptimized array bounds checking can take a signi cant toll on performance. How good is the performance that one can get out of Java t o d a y? Since Java is available on so many platforms, and multiple JVMs are available on each o f these, this is somewhat di cult to assess. Certainly, the variance in observed performance for a given application remains great. In order to track the progress of Java performance for numeric-intensive applications, Roldan Pozo and Bruce Miller of NIST have d e v eloped a Web-based benchmark called SciMark 33]. Sci-Mark combines ve medium-sized numerical kernels: complex-valued fast Fourier transformation, successive o ver-relaxation (SOR) iteration, Monte-Carlo quadrature of e ;x 2 , m ultiplication of sparsely populated matrices, and the LU factorization of dense matrices with pivoting. These are representative o f m a n y scienti c and engineering computations. For each o f t h e s e k ernels, a Java a n d a C v ersion are available. In addition, there is a small memory version, appropriate for studying cache-contained kernels, as well as one that exhibits out-of-cache behavior typical of large memory applications. The small problem Java v ersion of the benchmark is available as an applet at . This can be downloaded into a browser and run to assess the local environment. Composite results of the benchmark are reported in mega ops (M ops) results of the individual components are also available. The applet supports upload of the benchmark data to NIST, and the SciMark Web site maintains an archive of all uploaded results. These provide a snapshot of typical Java performance. For example, the antiquated JVM 1.1.5 of the Netscape browser reaches approximately 0.7 M ops on an Intel Celeron 366 processor under Linux and is, as such, 135 times slower than a C implementation on that platform. Java 1.1.8 is a huge improvement: using the same processor (running on OS/2) about 76 MFlops have c u r r e n tly been achieved | only 35% less than with C.

Scientific programmers have traditionally programmed in entirely sequential languages such as Fortran, C or Pascal and it could be argued that object-orientation is not a concept that they would need. Yet computer science departments that give courses to scientists and engineers would like to consider teaching them in Java, rather than in one of the older languages. This paper addresses the dual issues of how Java can best supply everything that the older languages do, and then what it can meaningfully give in added value, especially in the networking and parallel area. Experience with developing solutions in Java to some fifty typical numerical problems has led to a coherent objectoriented approach and a couple of essential support classes for teaching and production work.

Say you wish to process collections. Some may be collections of bytes, others collections of strings, and yet others collections of collections of strings. The Java programming language supports such variation by allowing you to form a collection of Object, so the elements may have any reference type. In order to keep the language simple, you are forced to do some of the work yourself: you must keep track of the fact that you have a collection of bytes, and when you extract an element from the collection you must cast it to class Byte before further processing. This situation is becoming more common as the Java platform evolves, notably with the addition of collection classes to JDK 1.2. Other languages provide additional support for this situation: in C++, it is supported with templates; in Ada, it is supported with generics; and in ML and Haskell, it is supported with parametric polymorphism. This note proposes GJ, an extension to the Java programming language that supports types with parameters. GJ programs look much like the equivalent Java programs, except they have more type information and fewer casts. The semantics of GJ is given by a translation into the Java programming language. The translation erases type parameters, replaces type variables by their bounding type (typically Object), adds casts, and inserts bridge methods so that overriding works properly. The resulting program is pretty much what you would write if generics weren't available. The translation is designed so that new GJ code will work with existing Java libraries, even when the libraries are available only in binary class file form. GJ comes with a cast-iron guarantee: no cast inserted by the compiler will ever fail. (Caveat: this guarantee is void if the compiler generates an unchecked warning, which may be necessary in certain cases for purposes of compatibility.) Furthermore, since GJ translates into Java virtual machine (JVM) byte codes, all safety and security properties of the Java platform are preserved.

The task of developing Java-based applications for embedded systems can be greatly enhanced by providing developers access to Java’s Core APIs such as java.lang and java.util. Oftentimes, platforms used in embedded systems are scaled back versions of the JVM. As a result, Core APIs must be migrated in order to be compatible with a particular platform. A significant portion of such migration centers around the removal of field, method, or constructor declarations. This paper describes the challenges and techniques associated with the automated removal-based modification of Java source code. Driving this research is the need to migrate selected Java Core APIs to an embedded platform called the SCore processor. This migration is being performed using a tool called Monarch.

Java's features such as system platform independence, dynamic and network oriented architecture, robustness as well as growing number of common standards make it a language of choice for many projects. However an increasing complexity of created software and requirement for high stability and high quality of applications make it desirable for a developer to inspect, monitor, debug or in any way alter Java programs behaviour on-the-fly. The main goal of this paper is to present the design of a system for instrumenting Java classes at runtime. This system is to aid developer in modifying program by adding fragments of code at specific locations that implement some new functionality. This allows programmer to enhance classes with logging, monitoring, caching or any other capabilities that are required at run-time.

Concurrent programming can lead to considerable performance gains on modern, parallel hardware when compared to single-core systems. When dealing with parallelization, however, developers have to explicitly address synchronization to safely access shared resources, which is typically achieved with locks. Choosing between simpler but less scalable and more sophisticated but error-prone locking mechanisms is difficult during development. Therefore, lock contention analysis at run time is crucial to aid in such decisions. I would also like to extend my thanks to the Christian Doppler Forschungsgesellschaft and to Dynatrace Austria for funding this work. Finally, I want to thank my friends and especially my family, who supported me during my studies at the Johannes Kepler University. I could not have accomplished all this without you. Thank you very much! Contents vii There are already various lock contention profilers for different languages and scenarios (cf. Chapter 6), but most of them do not capture all necessary information to actually fix any potential performance bottlenecks (e.g., where contention was caused). Those that do cannot universally be applied but rather are restricted to specific environments (e.g., bound to a specific virtual machine implementation) which may be problematic for the use in production systems.

Dynamic code evolution is a technique to update a program while it is running. In an object-oriented language such as Java, this can be seen as replacing a set of classes by new versions. We modified an existing high-performance virtual machine to allow arbitrary changes to the definition of loaded classes. Besides adding and deleting fields and methods, we also allow any kind of changes to the class and interface hierarchy. Our approach focuses on increasing developer productivity during debugging. Changes can be applied at any point a Java program can be suspended. The evaluation section shows that our modifications to the virtual machine have no negative performance impact on normal program execution. The fast in-place instance update algorithm ensures that the performance characteristics of a change are comparable with performing a full garbage collection run. Standard Java development environments are capable of using the code evolution features of our modified virtual machine, so no additional tools are required.

RESUMEN: Este artículo intenta hacer una reflexión teórica sobre Java que sea de interés y utilidad para la comunidad informática, y especialmente para los programadores de aplicaciones lingüísticas, ya que, como ocurre con muchas otras tecnologías asociadas con la Web, hay cierta confusión, falta de información y malentendidos sobre este lenguaje de programación. Aunque muchos lingüistas computacionales hayan oído hablar de Java, considerado su uso e incluso llegado hasta su primer applet (aplicación pequeña para una página Web) 'Hola mundo quizás no se hayan planteado todas las implicaciones del uso de este lenguaje y del papel que podría desempeñar en el desarrollo de aplicaciones lingüísticas hoy en día. Es necesario clarificar de antemano que aquí no se tiene el propósito de presentar Java como sustituto absoluto de los lenguajes de programación tradicionales para aplicaciones lingüísticas ya que, entre otras cosas, la historia de Java es demasiado corta para examinar comparativamente las aplicaciones escritas en este lenguaje y en otros y extraer conclusiones definitivas.

Teaching a new programming language in CS1 requires the instructor to make several important decisions regarding sequencing of topics. In teaching Java, the basic decisions center around how to perform input and output, when to teach the AWT ( Window Toolkit) and threads, whether to begin with applets or applications, and how much detail about object-oriented programming and Java language features is required in the beginning. This paper describes a "language features gently" approach to teaching CS1 in Java.

Scala is a versatile multi-paradigm general purpose programming language on the Java Virtual Machine, which offers full compatibility with existing Java libraries and code, while providing a multitude of advanced features compared to Java itself. Permission-based separation logic has proven to be a powerful formalism in reasoning about memory and concurrency in object-oriented programs-specifically in Java, but there are still challenges in reasoning about more advanced languages such as Scala. Of the features Scala provides beyond Java, this thesis focusses on first class functions and lexical closures. A formal model subset of Scala is defined, around these features. Using this foundation we present an extension to permission-based separation logic to specify and reason about functions and closures. Furtermore we provide a demonstration and an argument for its use by performing a case study on the Scala actors library.

This paper sets a goal of investigating the use of Java in the development of high integrity systems. Based on previous studies, guidelines, and standards, we develop 23 criteria that are used for the following assessment of Java. A summary of the assessment is provided before we go on to review a few existing subsets of the language.

Given the undeniable popularity of the Web, providing efficient and secure access to remote databases using a Web browser is crucial for the emerging cooperative information systems and applications. In this paper, we evaluate all currently available Java-based approaches that support persistent connections between Web clients and database servers. These approaches include Java applets, Java Sockets, Servlets, Remote Method Invocation, CORBA, and mobile agents technology. Our comparison is along the important parameters of performance and programmability.

The undeniable popularity of the web makes the efficient accessing of distributed databases from web clients an important topic. Various methods for web database integration have been proposed but recently there is an increasing interest on those based on Java-based ones. This is due to the inherent advantages of Java, which supports platform independence and secure program execution, and produces a small size of compiled code. In this experimental paper, we evaluate all currently available Java-based approaches. These include Java applets, Java Sockets, Servlets, Remote Method Invocation, CORBA, and Mobile Agents. To this end, we implemented a Web client accessing a remote database using each of these approaches and compared their behavior along the following important parameters: (1) performance expressed in terms of response time under different loads, (2) transparency of communication expressed in terms of complexity of networking API, and (3) extensibility expressed in terms of ease of adding new components.

The undeniable popularity of the web makes the efficient accessing of distributed databases from web clients an important topic. Various methods for web database integration have been proposed but recently there is an increasing interest on those based on Java-based ones. This is due to the inherent advantages of Java, which supports platform independence and secure program execution, and produces a small size of compiled code. In this experimental paper, we evaluate all currently available Java-based approaches. These include Java applets, Java Sockets, Servlets, Remote Method Invocation, CORBA, and Mobile Agents. To this end, we implemented a Web client accessing a remote database using each of these approaches and compared their behavior along the following important parameters: (1) performance expressed in terms of response time under different loads, (2) transparency of communication expressed in terms of complexity of networking API, and (3) extensibility expressed in terms of ease of adding new components.

MPJ Express is a thread-safe Java messaging library that provides a full implementation of the mpiJava 1.2 API specification. This specification defines a MPI-like bindings for the Java language. We have implemented two communication devices as part of our library, the first, called niodev is based on the Java New I/O package and the second, called mxdev is based on the Myrinet eXpress library. MPJ Express comes with an experimental runtime, which allows portable bootstrapping of Java Virtual Machines across a cluster or network of computers. In this paper we describe the implementation of MPJ Express. Also, we present a performance comparison against various other C and Java messaging systems. A beta version of MPJ Express was released in September 2005.

Recently, the demand for tool support (performance analyzers, debuggers etc.) for efficient Java programming is increasing. A universal, open interface between tools and a monitoring system, the On-line Monitoring Interface Specification (OMIS), and the OMIS compliant monitoring system (OCM) enable to specify such a Java oriented monitoring infrastructure which allows for an extensible range of functionality intended for supporting various kinds of tools. The paper presents an approach to building a monitoring system underlying this infrastructure.

I would not have been able to provide and complete this Thesis without the sincere support and help of many people. Foremost, I would like to thank my supervisor Dr. Steve Counsell for his patience, motivation, advice, and continuous help and support. He made my PhD journey an excellent experience with his knowledge, kindness, thoughtfulness and encouragement. I would like to dedicate my deep thanks for my mother, for the encouragement she provided, her unlimited patience, prayers and the sacrifices she made to help me after my father passed away, which without, I would not be able to achieve my goals and survive difficult times. I am greatly indebted to my sincere wife Dalia and my daughter Julie, without their hopeful smiles, emotional support, patience, understanding and infinite love I would not have been able to stand during the difficult moments in my PhD. I would like to convey my sincerest gratitude to my uncle Wahid Hamza who has been supportive through all my life stages. His sympathy and understanding were enormous and significantly appreciated. I am very grateful to all people in the Department of Information Systems and Computing at Brunel University who helped me during my study and provided such a friendly and comfortable environment. Last, but by no means least, I would like to thank all my friends and colleagues who have been my other family in the UK.

This paper describes a radical approach to aggressively optimize an embedded Java virtual machine interpretation in a portable way. We call this technique Semantically Enriched Code (sEc). The sEc technique can improve the speed of a JVM by orders of ...

The Distributed Real-Time Specification for Java (DRTSJ) is under development within Sun's Java Community Process (JCP) as Java Specification Request 50 (JSR-50), lead by the MITRE Corporation. We present the engineering considerations and design decisions settled by the Expert Group, the current and proposed form of the Reference Implementation, and a summary of open issues. In particular, we present an approach to integrating the distributable threads programming model with the Real-Time Specification for Java and discuss the ramifications for composing distributed, real-time systems in Java. The Expert Group plans to release an initial Early Draft Review (EDR) for previewing the distributable threads abstraction in the coming months, which we describe in detail. Along with that EDR, we will make available a demonstration application from Virginia Tech, and a DRTSJ-compatible RTSJ VM from Apogee.

Due to the successful development of the Internet, the course of distributed systems has received great attention by many universities and colleges in their computer science curricula. A comprehensive distributed system course involves many disciplines, such as ...

First proposed as a mechanism for enhancing Web content, the Java TM language has taken off as a serious general-purpose programming language. Industry and academia alike have expressed great interest in using the Java language as a programming language for scientific and engineering computations. Applications in these domains are characterized by intensive numerical computing and often have very high performance requirements. In this paper we discuss programming techniques that lead to Java numerical codes with performance comparable to FORTRAN or C, the more traditional languages for this field. The techniques are centered around the use of a high-performance numerical library, written entirely in the Java language, and on compiler technology. The numerical library takes the form of the Array package for Java. Proper use of this package, and of other appropriate tools for compiling and running a Java application, results in code that is clean, portable, and fast. We illustrate the programming and performance issues through case studies in data mining and electromagnetism.

Three nontrivial limitations of the existing Java T M technology are considered from the viewpoint of object-oriented database technology. The limitations are: lack of support for orthogonal persistence, lack of parametric (and in fact bounded and F-bounded) polymorphism and lack of an assertion (constraint) language. These limitations are overcome by leaving Java as it is, and developing a declarative (query in particular) component of the Java technology. This declarative language is implemented on top of the Java Virtual Machine, extended with orthogonal and transitive persistence. The model of persistence also features complex name space management.

As Java is being considered an appropriate environment for high performance computing, we describe advanced techniques of highly expressive and efficient combining of Java with existing code in other languages. We present their example use in developing of Java wrappers for the lip-a runtime support library which enables easy and portable parallelization of irregular and out-of-core problems. Sample performance comparison results of out-of-core computations in Java and C are also presented.

This paper describes Janet package-highly expressive Java language extension that enables convenient creation of powerful native methods and efficient Java-to-native code interfaces. Java native interface (JNI) is a low-level API that is rather inconvenient if used directly. Therefore Janet, as the higher-level tool, combines flexibility of JNI with Java's ease-of-use. Performance results of Janet-generated interface to the lip library are shown. Java code, which uses lip, is compared with native C implementation.

Java is growing in appropriateness and usability for high performance computing. With this increasing adoption, issues relating to combining Java with existing codes in other languages become more important. The Java Native Interface (JNI) API is portable but too inconvenient to be used directly owing to its low-level API. This paper presents Janet-a highly expressive Java language extension and preprocessing tool that enables convenient integration of native code with Java programs. The Janet methodology overcomes some of the limitations of JNI and generates Java programs that execute with little or no degradation despite the flexibility and generality of the interface.