Java Objects Research Articles

Virtual Program Counter (VPC) Prediction: Very Low Cost Indirect Branch Prediction Using Conditional Branch Prediction Hardware

Indirect branches have become increasingly common in modular programs written in modern object-oriented languages and virtual-machine-based runtime systems. Unfortunately, the prediction accuracy of indirect branches has not improved as much as that of conditional branches. Furthermore, previously proposed indirect branch predictors usually require a significant amount of extra hardware storage and complexity, which makes them less attractive to implement. This paper proposes a new technique for handling indirect branches, called Virtual Program Counter (VPC) prediction. The key idea of VPC prediction is to use the existing conditional branch prediction hardware to predict indirect branch targets, avoiding the need for a separate storage structure. Our comprehensive evaluation shows that VPC prediction improves average performance by 26.7 percent and reduces average energy consumption by 19 percent compared to a commonly used branch target buffer based predictor on 12 indirect branch intensive C/C++ applications. Moreover, VPC prediction improves the average performance of the full set of object-oriented Java DaCapo applications by 21.9 percent, while reducing their average energy consumption by 22 percent. We show that VPC prediction can be used with any existing conditional branch prediction mechanism and that the accuracy of VPC prediction improves when a more accurate conditional branch predictor is used.

Efficient memory management for hardware accelerated Java Virtual Machines

Application-specific hardware accelerators can significantly improve a system's performance. In a Java-based system, we then have to consider a hybrid architecture that consists of a Java Virtual Machine running on a general-purpose processor connected to the hardware accelerator. In such a hybrid architecture, data communication between the accelerator and the general-purpose processor can incur a significant cost, which may even annihilate the original performance improvement of adding the accelerator. A careful layout of the data in the memory structure is therefore of major importance to maintain the acceleration performance benefits. This article addresses the reduction of the communication cost in a distributed shared memory consisting of the main memory of the processor and the accelerator's local memory, which are unified in the Java heap. Since memory access times are highly nonuniform, a suitable allocation of objects in either main memory or the accelerator's local memory can significantly reduce the communication cost. We propose several techniques for finding the optimal location for each Java object's data, either statically through profiling or dynamically at runtime. We show how we can reduce communication cost by up to 86% for the SPECjvm and DaCapo benchmarks. We also show that the best strategy is application dependent and also depends on the relative cost of remote versus local accesses. For a relative cost higher than 10, a self-learning dynamic approach often results in the best performance.

Extending parameterized problem-tracing questions for Java with personalized guidance

Problem-tracing questions are popular among teachers of various programming languages. In an assessment mode these questions allows to evaluate student knowledge of language semantics. In a self-assessment mode, they provide an excellent learning tool. A 2004 ITiCSE working group report [4] stressed the importance of this type of questions to build foundation of higher-level knowledge. Yet the use of problem-tracing questions is still limited due to a large authoring overhead. To resolve this bottleneck, we explored the idea of parameterized question generation [2]. We developed QuizPACK [1], a system which can generate parameterized problem-tracing questions for C programming language. We also developed QuizGuide [1], a personalized guidance system for QuizPACK, which models student knowledge and guides students individually to most appropriate questions to try. The results of our studies demonstrated that QuizPACK strongly benefits student knowledge and that QuizGuide personalized guidance technology increased student ability to answer questions correctly and encouraged them to use the system more extensively (which, in turn, positively impacted their knowledge) [1]. However, parameterized questions in area of C programming were not as diverse from the complexity point of view as parameterized questions explored in other areas such as physics [2]. As a result, it was left unclear whether personalized guidance technology can successfully guide students to a broader range of questions from relatively simple to very difficult. The work reported in this poster expands our work on parameterized questions to a more sophisticated domain of object-oriented Java programming, which allowed us to introduce questions of much broader. Capitalizing on our experience with QuizPACK, we developed QuizJET (Java Evaluation Toolkit), which supports authoring, delivery, and evaluation of parameterized questions for Java [3]. We also implemented JavaGuide system (Figure 1), which provides personalized guidance for QuizJET questions. We assessed the impact of adaptive navigation support to student work with questions of different complexity as well as the impact of this technology on weaker and stronger students. The results of two classroom studies indicate that personalized guidance encouraged students to use parameterized questions more extensively and also helped them to access right questions at the right time. Students were 2.5 times more likely to answer a quiz correctly with personalized guidance than without such it. In addition, we found that personalized guidance especially benefited weak students to achieve scores comparable with the scores of strong students on each complexity level of questions.

Annotation refactoring

Since annotations were added to the Java language, many frameworks have moved to using annotated Plain Old Java Objects (POJOs) in their newest releases. Legacy applications are thus forced to undergo extensive restructuring in order to migrate from old framework versions to new versions based on annotations ( Version Lock-in ). Additionally, because annotations are embedded in the application code, changing between framework vendors may also entail largescale manual changes ( Vendor Lock-in ). This paper presents a novel refactoring approach that effectively solves these two problems. Our approach infers a concise set of semantics-preserving transformation rules from two versions of a single class. Unlike prior approaches that detect only simple structural refactorings, our algorithm can infer general composite refactorings and is more than 97% accurate on average. We demonstrate the effectiveness of our approach by automatically upgrading more than 80K lines of the unit testing code of four open-source Java applications to use the latest version of the popular JUnit testing framework.

Python puts a squeeze on java for CS0 and beyond

This paper compares Python with Java for teaching CS0, the first introductory course for computer science majors. Python has a simpler and more elegant syntax than Java. Python has an open, community-based development model managed by the non-profit Python Software Foundation; while Java is proprietary. Both Python and Java provide support for Graphical User Interfaces and object-oriented programming but Java seems to be more complex. These features make Python more suitable than Java for CS0 and more advanced courses.

분산 암호화를 이용한 웹 어플리케이션 보안

인터넷 사용자의 증가와 인터넷 쇼핑몰의 대중화로 인해 사용자가 요구하는 서비스의 양이 증가하고 있다. 이로 인해 웹 어플리케이션 시스템에는 서버의 과부하로 인한 성능 저하뿐만 아니라, 보안과 관련하여 많은 문제들이 발생한다. 또한 웹 어플리케이션 시스템에서는 클라이언트 요청에 의한 암호화가 필요하고 사용자를 인증하기 위한 공개키를 제공한다. 이때 발생하는 보안상 취약점을 해결하기 위한 방법으로 전달되는 메시지의 암호화와 공개키의 관리가 필요하다. 본 논문은 웹 어플리케이션 시스템에서 기밀성 및 인증을 제공함과 동시에, 다수의 클라이언트 접속 시 데이터의 암호화 처리로 인한 서버의 병목현상으로 인한 성능저하를 방지하고 서비스 질을 향상시키기 위한 방법으로 분산 암호화 시스템을 제안한다. 이러한 분산 암호화 시스템을 구현하기 위하여 자바의 객체 활성화 기술을 적용하였으며, 일부 분산서버의 다운타임에도 지속적인 서비스를 제공할 수 있도록 하였다. Quantity of encrypted data that transmitted through the network are increasing by development of encipherment technology. We have many problems; it is caused by technical development and service increase of user requests. It is necessary that create a many encryption key in one web application system. As a result, service quality comes to be low because of increased network traffic and system overload. There must be a system. That should be improved in secure service quality to process data. This paper describes a new approach for design and implementation of distributed encryption key processing for web application system. In this paper, it is based on distributed encipherment key, for the purpose of confidentially, integrity and authentication. It can prevent system degradation from server's data bottleneck and can improve service quality. For distributed encipherment system, we use java object activation technology. It can service while some distributed server are fail.

UniProtJAPI: a remote API for accessing UniProt data

Programmatic access to the UniProt Knowledgebase (UniProtKB) is essential for many bioinformatics applications dealing with protein data. We have created a Java library named UniProtJAPI, which facilitates the integration of UniProt data into Java-based software applications. The library supports queries and similarity searches that return UniProtKB entries in the form of Java objects. These objects contain functional annotations or sequence information associated with a UniProt entry. Here, we briefly describe the UniProtJAPI and demonstrate its usage.

Design and implementation of Web Services-based NGOSS technology-specific architecture

To cope with frequent changes and functional additions of operation and support systems (OSSs), a guideline of OSS’s architecture and development methods is needed. TeleManagement Forum has provided Next Generation Operations Systems and Software (NGOSS) technology-neutral architecture (TNA), which describes major concepts and architectural details of the NGOSS architecture in a technologically neutral manner. The TNA can be mapped onto technology-specific architectures (TSAs) using specific technologies such as Extensible Markup Language, Java, and Common Object Request Broker Architecture. Web Service, a distributed and service-oriented computing technology, can be also applied to NGOSS TSA. In this paper, we provide a design and implementation of Web Services-based TSA in accordance with the architectural principles of TNA and the performance evaluation of our proposed system. Our work can be used as a guideline for anyone planning to develop a Web Services-based NGOSS TSA.

A WEB-based integrated data processing system for the TRIAM-1M

In TRIAM-1M, plasma discharge can be sustained for over five hours [H. Zushi, et al., Steady-state tokamak operation, ITB transition and sustainment and ECCD experiments in TRIAM-1M, Nucl. Fusion 45 (2005) S142–S156]. In order to avoid sitting in front of one console for the purpose of monitoring the plasma discharge, it is recommended that the experimental information be accessible from any location at any time. In addition, simple services to access experimental information are required in order to promote the participation of multiple researchers in the TRIAM-1M experiment. Thus, A WEB-based integrated data processing system that provides management for experiment planning, an experimental log, numerical data, and plasma supervision has been installed in the TRIAM-1M. These services are composed primarily of an Apache WEB server, a Tomcat JSP/Servlet container, and a MySQL relational database. This system is constructed using the object-oriented Java language, which is easy to maintain and develop because of the intrinsic characteristics of the Java language. When participating in experiments, researchers are required only to prepare a WEB browser on any platform and are no longer required to memorize complex operations because all services are provided with a uniform user interface through a WEB browser. Furthermore, with the integration of these services, the required information and numerical data can be provided promptly by tracing HTML links that are created dynamically by server applications.

Java object header elimination for reduced memory consumption in 64-bit virtual machines

Memory performance is an important design issue for contemporary computer systems given the huge processor/memory speed gap. This paper proposes a space-efficient Java object model for reducing the memory consumption of 64-bit Java virtual machines. We completely eliminate the object header through typed virtual addressing (TVA) or implicit typing. TVA encodes the object type in the object's virtual address by allocating all objects of a given type in a contiguous memory segment. This allows for removing the type information as well as the status field from the object header. Whenever type and status information is needed, masking is applied to the object's virtual address for obtaining an offset into type and status information structures. Unlike previous work on implicit typing, we apply TVA to a selected number of frequently allocated object types, hence, the name selective TVA (STVA); this limits the amount of memory fragmentation. In addition to applying STVA, we also compress the type information block (TIB) pointers for all objects that do not fall under TVA. We implement the space-efficient Java object model in the 64-bit version of the Jikes RVM on an AIX IBM platform and compare its performance against the traditionally used Java object model using a multitude of Java benchmarks. We conclude that the space-efficient Java object model reduces memory consumption by on average 15% (and up to 45% for some benchmarks). About one-half the reduction comes from TIB pointer compression; the other one-half comes from STVA. In terms of performance, the space-efficient object model generally does not affect performance; however, for some benchmarks we observe statistically significant performance speedups, up to 20%.

Cyclone: java-based querying and computing with Pathway/Genome databases

Cyclone aims at facilitating the use of BioCyc, a collection of Pathway/Genome Databases (PGDBs). Cyclone provides a fully extensible Java Object API to analyze and visualize these data. Cyclone can read and write PGDBs, and can write its own data in the CycloneML format. This format is automatically generated from the BioCyc ontology by Cyclone itself, ensuring continued compatibility. Cyclone objects can also be stored in a relational database CycloneDB. Queries can be written in SQL, and in an intuitive and concise object-oriented query language, Hibernate Query Language (HQL). In addition, Cyclone interfaces easily with Java software including the Eclipse IDE for HQL edition, the Jung API for graph algorithms or Cytoscape for graph visualization. Cyclone is freely available under an open source license at: http://sourceforge.net/projects/nemo-cyclone. For download and installation instructions, tutorials, use cases and examples, see http://nemo-cyclone.sourceforge.net.

Runtime support for scalable programming in Java

The paper research is concerned with enabling parallel, high-performance computation--in particular development of scientific software in the network-aware programming language, Java. Traditionally, this kind of computing was done in Fortran. Arguably, Fortran is becoming a marginalized language, with limited economic incentive for vendors to produce modern development environments, optimizing compilers for new hardware, or other kinds of associated software expected of by today's programmers. Hence, Java looks like a very promising alternative for the future. The paper will discuss in detail a particular environment called HPJava. HPJava is the environment for parallel programming--especially data-parallel scientific programming--in Java. Our HPJava is based around a small set of language extensions designed to support parallel computation with distributed arrays, plus a set of communication libraries. A high-level communication API, Adlib, is developed as an application level communication library suitable for our HPJava. This communication library supports collective operations on distributed arrays. We include Java Object as one of the Adlib communication data types. So we fully support communication of intrinsic Java types, including primitive types, and Java object types.

Cluster Replication for Distributed-Java-Object Caching

Object caching is a common feature in the scalable distributed object systems. Fine-grained replication optimizes the performance and resource utilization in object caching by enabling a remote object-oriented application to be partially and incrementally on-demand replicated in units of cluster. Despite these benefits, the lack of common and simple implementation framework makes the fine-grained replication scheme not extensively used. This paper proposes the novel frameworks for dynamic, transparent, partial and automatically incremental replication of distributed Java objects based on three techniques that are lazy-object creation, proxy and hook. One framework enables the fine-grained replication of server-side stateful in-memory application, and the other framework enables the fine-grained replication of server-side stateless in-memory application, client-side program, or standalone application. The experimental evaluation demonstrates that the efficiency in terms of response time of both frameworks are relatively practical to the extent of a local method invocation.

Salal ( Gaultheria shallon) harvest: A plant architecture model

Salal ( Gaultheria shallon Pursh) is an evergreen shrub whose foliage is commercially harvested. An L-systems model of salal growth was developed to illustrate the effects of internode growth and axillary bud development on the architecture of individual salal plants. A Java program was then used to create an object-oriented salal model from the L-system structure. The object-oriented Java model was better able to construct the shoot parent–child relationships required for implementation of salal harvesters’ decision-making criteria than was the L-system approach which was better suited for modelling the plant growth and visualization. The visualization capabilities illustrated model performance that was consistent with field experiences, but relationships of salal growth to self-shading as well as overstory conditions require quantification before harvest effects on sustainability can be fully determined.

Metacomputing with Mobile Agents

In this paper we present Parallel Computing with Mobile Agents (PaCMAn), a mobile agent based Metacomputer that enables its users to utilize idle resources on the internet to tackle computational problems that could not be handled efficiently with their own resources. The PaCMAn launches multiple mobile agents that cooperate and communicate to solve problems in parallel. Each agent supports the basic communication and synchronization tasks of the classical parallel worker assuming the role of a process in a parallel processing application. Application tasks, however, are assigned dynamically to the PaCMAn's mobile agents via TaskHandlers. TaskHandlers are Java objects capable of implementing particular tasks of the application. The PaCMAn consists of three major components: Broker, Server and Client. A server machine has to be explicitly registered in order to take part in the PaCMAn Metacomputer. A number of brokers keep track of the available resources. In the PaCMAn system both server and client machines can be located anywhere in the Internet. The clients select the servers that they will utilize based on the specific resource requirements. We have developed and tested prototype systems with several applications. These prototypes provide proof of concept of our proposed Metacomputing philosophy. Furthermore they have demonstrated that PaCMAn provides parallel efficiency. We also demonstrate that the PaCMAn Metacomputer can be used as the computational engine for the creation of sophisticated Pervasive Services anywhere anytime.

On the prediction of Java object lifetimes

Accurately predicting object lifetimes is important for improving memory management systems. Current garbage collectors make relatively coarse-grained predictions (e.g., short-lived versus long-lived) and rely on application-independent heuristics related to the local characteristics of an allocation. This paper introduces a prediction method which is and makes its predictions based on application-specific training rather than application-independent heuristics. By fully precise we mean that the granularity of predictions is equal to the smallest unit of allocation. The method described is the first to combine high precision and efficiency in a single lifetime predictor. Fully prediction enables us, for the first time, to study zero-lifetime objects. The paper reports results showing that zero-lifetime objects comprise a significant fraction of object allocations in benchmark programs for the Java programming language and that they are correlated with their allocation context (the call stack and allocation site). Beyond zero-lifetime objects, the paper reports results on predicting longer lived objects, where, in some cases, it is possible to predict the lifetime of objects based on their allocation context (the call stack and allocation site) well. For the SPEC benchmark programs, the number of dynamically allocated objects whose call sites have accurate predictors ranges from 0.2 percent to 61 percent. This method could potentially improve the performance of garbage collectors. The paper proposes a death-ordered collector (DOC) and analyzes its implementation overheads and its best possible performance. The study shows how memory performance could be enhanced using the extra information provided by prediction.

A Common Information Model (CIM) Toolkit Framework Implemented in Java

The common information model (CIM) is an object-oriented representation of a power system and is used primarily as a data exchange format for power system operational control systems. CIM has the potential to be used as much more than an intermediary exchange language. This paper explores the possible use of CIM as the core of a power systems analytical toolkit for storing, processing, extracting, and exchanging data directly from CIM objects. To this end, this paper discusses solutions to some of the challenges in storing and processing large power system network models as native Java objects without sacrificing reliability and robustness. This paper highlights the advantages provided by such a system when dealing with extensions to the CIM standard and overcoming the problems posed with simultaneously maintaining backward compatibility without sacrificing a higher level of detail. This paper also addresses the issue of data processing performance in contrast to other approaches.

Encrypting the Java Serialized Object.

The cryptographic classes incorporated into Sun’s releases of the Java Virtual Machine are often used in e-commerce and other applications. A mechanism exists for signing a Java Class. However, little notice has been given to the possibility of encrypting the Java object instance itself, either for transmission or to maintain state during storage. In this article, we discuss the applicable techniques and benefits of using DES, TripleDES, Blowfish and AES symmetric secret-key algorithms to encrypt a Java serializeable object using technology available through public means.

The TEXTOR diagnostic data management chain

Abstract During the 2002–2003 shutdown of TEXTOR, many components of the TEXTOR diagnostic data management system were upgraded. This paper intents to give an overview of these upgraded components and how they co-operate to form one integrated Data Management System. The components in question are: (1) JDAQ: The Java (or Juelich) Data Acquisition System, a newly created data acquisition system, completely written in the JAVA object oriented programming language. (2) The TEC Common Storage Facility and the Textor Physics Database. (3) The TEC Web-Umbrella: A unified data access scheme based on the widely used HTTP protocol. (4) Chainl: A framework for automatically run chains of analysis software.

Dynamic load‐balancing mechanism for distributed Java applications

AbstractProgram environments or operating systems generally leave the decision on the allocation of program entities to the developer, offering either placement directives, or tools available through the manipulation of a graphical interface. These approaches cannot always take into account the dynamic behavior of applications, dynamicity in the execution environment or the heterogeneity of the execution platform. Transparent deployment algorithms are necessary for automizing and optimizing application distribution. The Adaptive Distributed Applications in Java (ADAJ) project deals with placement and migration of Java objects. It automatically deploys parallel Java applications on a cluster of workstations using monitoring information about the application behavior. The transparency obtained through the integration of these tools in the middleware makes such an environment easy to use and improves efficiency. Copyright © 2005 John Wiley & Sons, Ltd.