Home About us Contact
|
Home About us Contact | ||
|
|
||
Java
Kinds of Java Terms modified by Java Selected AbstractsA flexible framework for consistency managementCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 1 2002S. Weber Abstract Recent distributed shared memory (DSM) systems provide increasingly more support for the sharing of objects rather than portions of memory. However, like earlier DSM systems these distributed shared object systems (DSO) still force developers to use a single protocol, or a small set of given protocols, for the sharing of application objects. This limitation prevents the applications from optimizing their communication behaviour and results in unnecessary overhead. A current general trend in software systems development is towards customizable systems, for example frameworks, reflection, and aspect-oriented programming all aim to give the developer greater flexibility and control over the functionality and performance of their code. This paper describes a novel object-oriented framework that defines a DSM system in terms of a consistency model and an underlying coherency protocol. Different consistency models and coherency protocols can be used within a single application because they can be customized, by the application programmer, on a per-object basis. This allows application specific semantics to be exploited at a very fine level of granularity and with a resulting improvement in performance. The framework is implemented in JAVA and the speed-up obtained by a number of applications that use the framework is reported. Copyright © 2002 John Wiley & Sons, Ltd. [source] On the effectiveness of clone detection by string matchingJOURNAL OF SOFTWARE MAINTENANCE AND EVOLUTION: RESEARCH AND PRACTICE, Issue 1 2006Stéphane Ducasse Abstract Although duplicated code is known to pose severe problems for software maintenance, it is difficult to identify in large systems. Many different techniques have been developed to detect software clones, some of which are very sophisticated, but are also expensive to implement and adapt. Lightweight techniques based on simple string matching are easy to implement, but how effective are they? We present a simple string-based approach which we have successfully applied to a number of different languages such COBOL, JAVA, C++, PASCAL, PYTHON, SMALLTALK, C and PDP-11 ASSEMBLER. In each case the maximum time to adapt the approach to a new language was less than 45 minutes. In this paper we investigate a number of simple variants of string-based clone detection that normalize differences due to common editing operations, and assess the quality of clone detection for very different case studies. Our results confirm that this inexpensive clone detection technique generally achieves high recall and acceptable precision. Over-zealous normalization of the code before comparison, however, can result in an unacceptable numbers of false positives. Copyright © 2005 John Wiley & Sons, Ltd. [source] A web-based tool for teaching neural network conceptsCOMPUTER APPLICATIONS IN ENGINEERING EDUCATION, Issue 3 2010Aybars Ugur Abstract Although neural networks (NN) are important especially for engineers, scientists, mathematicians and statisticians, they may also be hard to understand. In this article, application areas of NN are discussed, basic NN components are described and it is explained how an NN work. A web-based simulation and visualization tool (EasyLearnNN) is developed using Java and Java 2D for teaching NN concepts. Perceptron, ADALINE, Multilayer Perceptron, LVQ and SOM models and related training algorithms are implemented. As a result, comparison with other teaching methods of NN concepts is presented and discussed. © 2009 Wiley Periodicals, Inc. Comput Appl Eng Educ 18: 449,457, 2010; View this article online at wileyonlinelibrary.com; DOI 10.1002/cae.20184 [source] An object-oriented design and reference implementation for web-based instructional softwareCOMPUTER APPLICATIONS IN ENGINEERING EDUCATION, Issue 1 2005Shrimalini Jayaramaraja Abstract There is an increasing global demand for web-based instructional software. The functional requirements and object-oriented design for a typical web-based instructional system are presented here using the Unified Modeling Language (UML). An interactive, reusable and scalable reference implementation of this model is developed in Java. Several deployment strategies are discussed. © 2005 Wiley Periodicals, Inc. Comput Appl Eng Educ 13: 26,39, 2005; Published online in Wiley InterScience (www.interscience.wiley.com); DOI 10.1002/cae.20027 [source] Java applet on computation of thermodynamic properties of steam and R134a refrigerantCOMPUTER APPLICATIONS IN ENGINEERING EDUCATION, Issue 4 2003F. L. Tan Abstract This paper describes the application of Java programming on the computation of thermodynamic properties of steam and the HFC-134a, 1,1,1,2-tetrafluoroethane (R134a) refrigerant through the Java applets. The Java applets can compute thermodynamic properties of steam and R134a refrigerant, such as specific volume, internal energy, enthalpy, and entropy in the phases of saturated mixture, compressed liquid, and superheated vapor. The calculated values are accurate compared to the standard reference properties tables for steam and refrigerant. © 2004 Wiley Periodicals, Inc. Comput Appl Eng Educ 11: 211,225, 2003; Published online in Wiley InterScience (www.interscience.wiley.com); DOI 10.1002/cae.10049 [source] Novel software architecture for rapid development of magnetic resonance applicationsCONCEPTS IN MAGNETIC RESONANCE, Issue 3 2002Josef Debbins Abstract As the pace of clinical magnetic resonance (MR) procedures grows, the need for an MR scanner software platform on which developers can rapidly prototype, validate, and produce product applications becomes paramount. A software architecture has been developed for a commercial MR scanner that employs state of the art software technologies including Java, C++, DICOM, XML, and so forth. This system permits graphical (drag and drop) assembly of applications built on simple processing building blocks, including pulse sequences, a user interface, reconstruction and postprocessing, and database control. The application developer (researcher or commercial) can assemble these building blocks to create custom applications. The developer can also write source code directly to create new building blocks and add these to the collection of components, which can be distributed worldwide over the internet. The application software and its components are developed in Java, which assures platform portability across any host computer that supports a Java Virtual Machine. The downloaded executable portion of the application is executed in compiled C++ code, which assures mission-critical real-time execution during fast MR acquisition and data processing on dedicated embedded hardware that supports C or C++. This combination permits flexible and rapid MR application development across virtually any combination of computer configurations and operating systems, and yet it allows for very high performance execution on actual scanner hardware. Applications, including prescan, are inherently real-time enabled and can be aggregated and customized to form "superapplications," wherein one or more applications work with another to accomplish the clinical objective with a very high transition speed between applications. © 2002 Wiley Periodicals, Inc. Concepts in Magnetic Resonance (Magn Reson Engineering) 15: 216,237, 2002 [source] A comparative study of Java and C performance in two large-scale parallel applicationsCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 15 2009Aamir Shafi Abstract In the 1990s the Message Passing Interface Forum defined MPI bindings for Fortran, C, and C++. With the success of MPI these relatively conservative languages have continued to dominate in the parallel computing community. There are compelling arguments in favour of more modern languages like Java. These include portability, better runtime error checking, modularity, and multi-threading. But these arguments have not converted many HPC programmers, perhaps due to the scarcity of full-scale scientific Java codes, and the lack of evidence for performance competitive with C or Fortran. This paper tries to redress this situation by porting two scientific applications to Java. Both of these applications are parallelized using our thread-safe Java messaging system,MPJ Express. The first application is the Gadget-2 code, which is a massively parallel structure formation code for cosmological simulations. The second application uses the finite-domain time-difference method for simulations in the area of computational electromagnetics. We evaluate and compare the performance of the Java and C versions of these two scientific applications, and demonstrate that the Java codes can achieve performance comparable with legacy applications written in conventional HPC languages. Copyright © 2009 John Wiley & Sons, Ltd. [source] Accurate garbage collection in uncooperative environments revisited,CONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 12 2009J. Baker Abstract Implementing a concurrent programming language such as Java by means of a translator to an existing language is attractive as it provides portability over all platforms supported by the host language and reduces development time,as many low-level tasks can be delegated to the host compiler. The C and C++ programming languages are popular choices for many language implementations due to the availability of efficient compilers on a wide range of platforms. For garbage-collected languages, however, they are not a perfect match as no support is provided for accurately discovering pointers to heap-allocated data on thread stacks. We evaluate several previously published techniques and propose a new mechanism, lazy pointer stacks, for performing accurate garbage collection in such uncooperative environments. We implemented the new technique in the Ovm Java virtual machine with our own Java-to-C/C++ compiler using GCC as a back-end compiler. Our extensive experimental results confirm that lazy pointer stacks outperform existing approaches: we provide a speedup of 4.5% over Henderson's accurate collector with a 17% increase in code size. Accurate collection is essential in the context of real-time systems, we thus validate our approach with the implementation of a real-time concurrent garbage collection algorithm. Copyright © 2009 John Wiley & Sons, Ltd. [source] Parallel programming on a high-performance application-runtimeCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 18 2008Wojtek James Goscinski Abstract High-performance application development remains challenging, particularly for scientists making the transition to a heterogeneous grid environment. In general areas of computing, virtual environments such as Java and .Net have proved to be successful in fostering application development, allowing users to target and compile to a single environment, rather than a range of platforms, instruction sets and libraries. However, existing runtime environments are focused on business and desktop computing and they do not support the necessary high-performance computing (HPC) abstractions required by e-Scientists. Our work is focused on developing an application-runtime that can support these services natively. The result is a new approach to the development of an application-runtime for HPC: the Motor system has been developed by integrating a high-performance communication library directly within a virtual machine. The Motor message passing library is integrated alongside and in cooperation with other runtime libraries and services while retaining a strong message passing performance. As a result, the application developer is provided with a common environment for HPC application development. This environment supports both procedural languages, such as C, and modern object-oriented languages, such as C#. This paper describes the unique Motor architecture, presents its implementation and demonstrates its performance and use. Copyright © 2008 John Wiley & Sons, Ltd. [source] Java multithreading-based parallel approximate arrow-type inversesCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 10 2008George A. Gravvanis Abstract A new parallel shared memory Java multithreaded design and implementation of the explicit approximate inverse preconditioning, for efficiently solving arrow-type linear systems on symmetric multiprocessor systems (SMPs), is presented. A new parallel algorithm for computing a class of optimized approximate arrow-type inverse matrix is introduced. The performance on an SMP, using Java multithreading, is investigated by solving arrow-type linear systems and numerical results are given. The parallel performance of the construction of the optimized approximate inverse and the explicit preconditioned generalized conjugate gradient square scheme, using a dynamic workload scheduling, is also presented. Copyright © 2007 John Wiley & Sons, Ltd. [source] Babylon: middleware for distributed, parallel, and mobile Java applicationsCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 10 2008Willem van Heiningen Abstract Babylon is a collection of tools and services that provide a 100% Java-compatible environment for developing, running and managing parallel, distributed and mobile Java applications. It incorporates features such as object migration, asynchronous method invocation, and remote class loading, while providing an easy-to-use interface. Additionally, Babylon enables Java applications to seamlessly create and interact with remote objects, while protecting those objects from other applications by implementing access restrictions and separate namespaces. The implementation of Babylon centers around dynamic proxies, a feature first available in Java 1.3, that allow proxy objects to be created at runtime. Dynamic proxies play a key role in achieving the goals of Babylon. The potential cluster computing benefits of the system are demonstrated with experimental results, which show that sequential Java applications can achieve significant performance benefits from using Babylon to parallelize their work across a cluster of workstations. Copyright © 2008 John Wiley & Sons, Ltd. [source] JaMP: an implementation of OpenMP for a Java DSMCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 18 2007Michael Klemm Abstract Although OpenMP is a widely agreed-upon standard for the C/C++ and Fortran programming languages for the semi-automatic parallelization of programs for shared memory machines, not much has been done on the binding of OpenMP to Java that targets clusters with distributed memory. This paper presents three major contributions: (1) JaMP is an adaptation of the OpenMP standard to Java that implements a large subset of the OpenMP specification with an expressiveness comparable to that of OpenMP; (2) we suggest a set of extensions that allow a better integration of OpenMP into the Java language; (3) we present our prototype implementation of JaMP in the research compiler Jackal, a software-based distributed shared memory implementation for Java. We evaluate the performance of JaMP with a set of micro-benchmarks and with OpenMP versions of the parallel Java Grande Forum (JGF) benchmarks. The micro-benchmarks show that OpenMP for Java can be implemented without much overhead. The JGF benchmarks achieve a good speed-up of 5,8 on eight nodes. Copyright © 2007 John Wiley & Sons, Ltd. [source] MyCoG.NET: a multi-language CoG toolkitCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 14 2007A. Paventhan Abstract Grid application developers utilize Commodity Grid (CoG) toolkits to access Globus Grid services. Existing CoG toolkits are language-specific and have, for example, been developed for Java, Python and the Matlab scripting environment. In this paper we describe MyCoG.NET, a CoG toolkit supporting multi-language programmability under the Microsoft .NET framework. MyCoG.NET provides a set of classes and APIs to access Globus Grid services from languages supported by the .NET Common Language Runtime. We demonstrate its programmability using FORTRAN, C++, C# and Java, and discuss its performance over LAN and WAN infrastructures. We present a Grid application, in the field of experimental aerodynamics, as a case study to show how MyCoG.NET can be exploited. We demonstrate how scientists and engineers can create and use domain-specific workflow activity sets for rapid application development using Windows Workflow Foundation. We also show how users can easily extend and customize these activities. Copyright © 2006 John Wiley & Sons, Ltd. [source] A new task scheduling method for distributed programs that require memory managementCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 9 2006Hiroshi Koide Abstract In parallel and distributed applications, it is very likely that object-oriented languages, such as Java and Ruby, and large-scale semistructured data written in XML will be employed. However, because of their inherent dynamic memory management, parallel and distributed applications must sometimes suspend the execution of all tasks running on the processors. This adversely affects their execution on the parallel and distributed platform. In this paper, we propose a new task scheduling method called CP/MM (Critical Path/Memory Management) which can efficiently schedule tasks for applications requiring memory management. The underlying concept is to consider the cost due to memory management when the task scheduling system allocates ready (executable) coarse-grain tasks, or macro-tasks, to processors. We have developed three task scheduling modules, including CP/MM, for a task scheduling system which is implemented on a Java RMI (Remote Method Invocation) communication infrastructure. Our experimental results show that CP/MM can successfully prevent high-priority macro-tasks from being affected by the garbage collection arising from memory management, so that CP/MM can efficiently schedule distributed programs whose critical paths are relatively long. Copyright © 2005 John Wiley & Sons, Ltd. [source] A robust monitor construct with runtime fault detection,CONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 5 2006Jiannong Cao Abstract The monitor concept provides a structured and flexible high-level programming construct to control concurrent accesses to shared resources. It has been widely used in a concurrent programming environment for implicitly ensuring mutual exclusion and explicitly achieving process synchronization. This paper proposes an extension to the monitor construct for detecting runtime errors in monitor operations. Monitors are studied and classified according to their functional characteristics. A taxonomy of concurrency control faults over a monitor is then defined. The concepts of a monitor event sequence and a monitor state sequence provide a uniform approach to history information recording and fault detection. Rules for detecting various types of faults are defined. Based on these rules, fault-detection algorithms are developed. A prototypical implementation of the proposed monitor construct with runtime fault detection mechanisms has been developed in Java. We shall briefly report our experience with and the evaluation of the robust monitor prototype. Copyright © 2005 John Wiley & Sons, Ltd. [source] JAC: declarative Java concurrencyCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 5 2006Max Haustein Abstract The Java programming language has a low-level concurrency model which is hard to use and does not blend well with inheritance. JAC is an extension of Java that introduces a higher level of concurrency, hiding threads and separating thread synchronization from application logic in a declarative fashion. The emphasis is on limiting the differences between sequential and concurrent code, thus furthering code reuse, and on avoiding inheritance anomalies. This is achieved by taking a middle road between concurrent code on the one hand and complete separation of sequential application logic from concurrency mechanisms on the other. An extensive comparison with related approaches is given for motivating our design decisions. Copyright © 2005 John Wiley & Sons, Ltd. [source] Dynamic load-balancing mechanism for distributed Java applicationsCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 3 2006Violeta Felea Abstract Program 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. [source] JOPI: a Java object-passing interfaceCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 7-8 2005Jameela Al-Jaroodi Abstract Recently there has been an increasing interest in developing parallel programming capabilities in Java to harness the vast resources available in clusters, grids and heterogeneous networked systems. In this paper, we introduce a Java object-passing interface (JOPI) library. JOPI provides Java programmers with the necessary functionality to write object-passing parallel programs in distributed heterogeneous systems. JOPI provides a Message Passing Interface (MPI)-like interface that can be used to exchange objects among processes. In addition to the well-known benefits of the object-oriented development model, using objects to exchange information in JOPI is advantageous because it facilitates passing complex structures and enables the programmer to isolate the problem space from the parallelization problem. The run-time environment for JOPI is portable, efficient and provides the necessary functionality to deploy and execute parallel Java programs. Experiments were conducted on a cluster system and a collection of heterogeneous platforms to measure JOPI's performance and compare it with MPI. The results show good performance gains using JOPI. Copyright © 2005 John Wiley & Sons, Ltd. [source] Advanced eager scheduling for Java-based adaptive parallel computingCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 7-8 2005Michael O. Neary Abstract Javelin 3 is a software system for developing large-scale, fault-tolerant, adaptively parallel applications. When all or part of their application can be cast as a master,worker or branch-and-bound computation, Javelin 3 frees application developers from concerns about inter-processor communication and fault tolerance among networked hosts, allowing them to focus on the underlying application. The paper describes a fault-tolerant task scheduler and its performance analysis. The task scheduler integrates work stealing with an advanced form of eager scheduling. It enables dynamic task decomposition, which improves host load-balancing in the presence of tasks whose non-uniform computational load is evident only at execution time. Speedup measurements are presented of actual performance on up to 1000 hosts. We analyze the expected performance degradation due to unresponsive hosts, and measure actual performance degradation due to unresponsive hosts. Copyright © 2005 John Wiley & Sons, Ltd. [source] Ibis: a flexible and efficient Java-based Grid programming environmentCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 7-8 2005Rob V. van Nieuwpoort Abstract In computational Grids, performance-hungry applications need to simultaneously tap the computational power of multiple, dynamically available sites. The crux of designing Grid programming environments stems exactly from the dynamic availability of compute cycles: Grid programming environments (a) need to be portable to run on as many sites as possible, (b) they need to be flexible to cope with different network protocols and dynamically changing groups of compute nodes, while (c) they need to provide efficient (local) communication that enables high-performance computing in the first place. Existing programming environments are either portable (Java), or flexible (Jini, Java Remote Method Invocation or (RMI)), or they are highly efficient (Message Passing Interface). No system combines all three properties that are necessary for Grid computing. In this paper, we present Ibis, a new programming environment that combines Java's ,run everywhere' portability both with flexible treatment of dynamically available networks and processor pools, and with highly efficient, object-based communication. Ibis can transfer Java objects very efficiently by combining streaming object serialization with a zero-copy protocol. Using RMI as a simple test case, we show that Ibis outperforms existing RMI implementations, achieving up to nine times higher throughputs with trees of objects. Copyright © 2005 John Wiley & Sons, Ltd. [source] Adding tuples to Java: a study in lightweight data structuresCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 5-6 2005C. van Reeuwijk Abstract Java classes are very flexible, but this comes at a price. The main cost is that every class instance must be dynamically allocated. Also, their access by reference introduces pointer de-references and complicates program analysis. These costs are particularly burdensome for small, ubiquitous data structures such as coordinates and state vectors. For such data structures a lightweight representation is desirable, allowing such data to be handled directly, similar to primitive types. A number of proposals introduce restricted or mutated variants of standard Java classes that could serve as lightweight representation, but the impact of these proposals has never been studied. Since we have implemented a Java compiler with lightweight data structures we are in a good position to do this evaluation. Our lightweight data structures are tuples. As we will show, using tuples can result in significant performance gains: for a number of existing benchmark programs we gain more than 50% in performance relative to our own compiler, and more than 20% relative to Sun's Hotspot 1.4 compiler. We expect similar performance gains for other implementations of lightweight data structures. With respect to the expressiveness of Java, lightweight variants of standard Java classes have little impact. In contrast, tuples add a different language construct that, as we will show, can lead to substantially more concise program code. Copyright © 2005 John Wiley & Sons, Ltd. [source] Object combining: a new aggressive optimization for object intensive programsCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 5-6 2005Ronald Veldema Abstract Object combining tries to put objects together that have roughly the same life times in order to reduce strain on the memory manager and to reduce the number of pointer indirections during a program's execution. Object combining works by appending the fields of one object to another, allowing allocation and freeing of multiple objects with a single heap (de)allocation. Unlike object inlining, which will only optimize objects where one has a (unique) pointer to another, our optimization also works if there is no such relation. Object inlining also directly replaces the pointer by the inlined object's fields. Object combining leaves the pointer in place to allow more combining. Elimination of the pointer accesses is implemented in a separate compiler optimization pass. Unlike previous object inlining systems, reference field overwrites are allowed and handled, resulting in much more aggressive optimization. Our object combining heuristics also allow unrelated objects to be combined, for example, those allocated inside a loop; recursive data structures (linked lists, trees) can be allocated several at a time and objects that are always used together can be combined. As Java explicitly permits code to be loaded at runtime and allows the new code to contribute to a running computation, we do not require a closed-world assumption to enable these optimizations (but it will increase performance). The main focus of object combining in this paper is on reducing object (de)allocation overhead, by reducing both garbage collection work and the number of object allocations. Reduction of memory management overhead causes execution time to be reduced by up to 35%. Indirection removal further reduces execution time by up to 6%. Copyright © 2005 John Wiley & Sons, Ltd. [source] Linda implementations in Java for concurrent systemsCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 10 2004G. C. Wells Abstract This paper surveys a number of the implementations of Linda that are available in Java. It provides some discussion of their strengths and weaknesses, and presents the results from benchmarking experiments using a network of commodity workstations. Some extensions to the original Linda programming model are also presented and discussed, together with examples of their application to parallel processing problems. Copyright © 2004 John Wiley & Sons, Ltd. [source] Data structures in Java for matrix computationsCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 8 2004Geir Gundersen Abstract In this paper we show how to utilize Java's native arrays for matrix computations. The disadvantages of Java arrays used as a 2D array for dense matrix computation are discussed and ways to improve the performance are examined. We show how to create efficient dynamic data structures for sparse matrix computations using Java's native arrays. This data structure is unique for Java and shown to be more dynamic and efficient than the traditional storage schemes for large sparse matrices. Numerical testing indicates that this new data structure, called Java Sparse Array, is competitive with the traditional Compressed Row Storage scheme on matrix computation routines. Java gives increased flexibility without losing efficiency. Compared with other object-oriented data structures Java Sparse Array is shown to have the same flexibility. Copyright © 2004 John Wiley & Sons, Ltd. [source] Simple verification technique for complex Java bytecode subroutinesCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 7 2004Alessandro Coglio Abstract Java is normally compiled to bytecode, which is verified and then executed by the Java Virtual Machine. Bytecode produced via compilation must pass verification. The main cause of complexity for bytecode verification is subroutines, used by compilers to generate more compact code. The techniques to verify subroutines proposed in the literature reject certain programs produced by mundane compilers, are difficult to realize within an implementation of the Java Virtual Machine or are relatively complicated. This paper presents a novel technique which is very simple to understand, implement and prove sound. It is also very powerful: the set of accepted programs has a simple characterization which most likely includes all the code produced by current compilers and which enables future compilers to make more extensive use of subroutines. Copyright © 2004 John Wiley & Sons, Ltd. [source] Analysing the Java package/access concepts in Isabelle/HOLCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 7 2004Norbert Schirmer Abstract Java access modifiers and packages provide a mechanism to restrict access to members and types, as an additional means of information hiding beyond the purely object-oriented concept of classes. In this paper we clarify the semantics of access modifiers and packages by adding them to our formal model of Java in the theorem prover Isabelle/HOL. We analyse which properties we can rely on at runtime, provided that the program has passed the static accessibility tests. Copyright © 2004 John Wiley & Sons, Ltd. [source] Sapphire: copying garbage collection without stopping the worldCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 3-5 2003Richard L. Hudson Abstract The growing use in concurrent systems of languages that require garbage collection (GC), such as Java, is raising practical interest in concurrent GC. Sapphire is a new algorithm for concurrent copying GC for Java. It stresses minimizing the amount of time any given application thread may need to block to support the collector. In particular, Sapphire is intended to work well in the presence of a large number of application threads, on small- to medium-scale shared memory multiprocessors. Sapphire extends previous concurrent copying algorithms, and is most closely related to replicating copying collection, a GC technique in which application threads observe and update primarily the old copies of objects. The key innovations of Sapphire are: (1) the ability to ,flip' one thread at a time (changing the thread's view from the old copies of objects to the new copies), as opposed to needing to stop all threads and flip them at the same time; (2) exploiting Java semantics and assuming any data races occur on volatile fields, to avoid a barrier on reads of non-volatile fields; and (3) working in concert with virtually any underlying (non-concurrent) copying collection algorithm. Copyright © 2003 John Wiley & Sons, Ltd. [source] Object-oriented distributed computing based on remote class referenceCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 1 2003Yan Huang Abstract Java RMI, Jini and CORBA provide effective mechanisms for implementing a distributed computing system. Recently many numeral libraries have been developed that take advantage of Java as an object-oriented and portable language. The widely-used client-server method limits the extent to which the benefits of the object-oriented approach can be exploited because of the difficulties arising when a remote object is the argument or return value of a remote or local method. In this paper this problem is solved by introducing a data object that stores the data structure of the remote object and related access methods. By using this data object, the client can easily instantiate a remote object, and use it as the argument or return value of either a local or remote method. Copyright © 2003 John Wiley & Sons, Ltd. [source] Simulating multiple inheritance in JavaCONCURRENCY AND COMPUTATION: PRACTICE & EXPERIENCE, Issue 12 2002Douglas Lyon Abstract The CentiJ system automatically generates code that simulates multiple inheritance in Java. The generated code inputs a series of instances and outputs specifications that can be combined using multiple inheritance. The multiple inheritance of implementation is obtained by simple message forwarding. The reflection API of Java is used to reverse engineer the instances, and so the program can generate source code, but does not require source code on its input. Advantages of CentiJ include compile-time type checking, speed of execution, automatic disambiguation (name space collision resolution) and ease of maintenance. Simulation of multiple inheritance was previously available only to Java programmers who performed manual delegation or who made use of dynamic proxies. The technique has been applied at a major aerospace corporation. Copyright © 2002 John Wiley & Sons, Ltd. [source] Ecological niche modelling as a technique for assessing threats and setting conservation priorities for Asian slow lorises (Primates: Nycticebus)DIVERSITY AND DISTRIBUTIONS, Issue 2 2009J. S. Thorn ABSTRACT Aim, Data on geographical ranges are essential when defining the conservation status of a species, and in evaluating levels of human disturbance. Where locality data are deficient, presence-only ecological niche modelling (ENM) can provide insights into a species' potential distribution, and can aid in conservation planning. Presence-only ENM is especially important for rare, cryptic and nocturnal species, where absence is difficult to define. Here we applied ENM to carry out an anthropogenic risk assessment and set conservation priorities for three threatened species of Asian slow loris (Primates: Nycticebus). Location, Borneo, Java and Sumatra, Southeast Asia. Methods, Distribution models were built using maximum entropy (MaxEnt) ENM. We input 20 environmental variables comprising temperature, precipitation and altitude, along with species locality data. We clipped predicted distributions to forest cover and altitudinal data to generate remnant distributions. These were then applied to protected area (PA) and human land-use data, using specific criteria to define low-, medium- or high-risk areas. These data were analysed to pinpoint priority study sites, suitable reintroduction zones and protected area extensions. Results, A jackknife validation method indicated highly significant models for all three species with small sample sizes (n = 10 to 23 occurrences). The distribution models represented high habitat suitability within each species' geographical range. High-risk areas were most prevalent for the Javan slow loris (Nycticebus javanicus) on Java, with the highest proportion of low-risk areas for the Bornean slow loris (N. menagensis) on Borneo. Eighteen PA extensions and 23 priority survey sites were identified across the study region. Main conclusions, Discriminating areas of high habitat suitability lays the foundations for planning field studies and conservation initiatives. This study highlights potential reintroduction zones that will minimize anthropogenic threats to animals that are released. These data reiterate the conclusion of previous research, showing MaxEnt is a viable technique for modelling species distributions with small sample sizes. [source] | |||||||||||||||||||||||||||||||