Showing papers on "Software portability published in 2005"

ViSP for visual servoing: a generic software platform with a wide class of robot control skills

Abstract: ViSP (Visual Servoing Platform), a fully functional modular architecture that allows fast development of visual servoing applications, is described. The platform takes the form of a library which can be divided in three main modules: control processes, canonical vision-based tasks that contain the most classical linkages, and real-time tracking. ViSP software environment features independence with respect to the hardware, simplicity, extendibility, and portability. ViSP also features a large library of elementary tasks with various visual features that can be combined together, an image processing library that allows the tracking of visual cues at video rate, a simulator, an interface with various classical framegrabbers, a virtual 6-DOF robot that allows the simulation of visual servoing experiments, etc. The platform is implemented in C++ under Linux.

PlayAnywhere: a compact interactive tabletop projection-vision system

Abstract: We introduce PlayAnywhere, a front-projected computer vision-based interactive table system which uses a new commercially available projection technology to obtain a compact, self-contained form factor. PlayAnywhere's configuration addresses installation, calibration, and portability issues that are typical of most vision-based table systems, and thereby is particularly motivated in consumer applications. PlayAnywhere also makes a number of contributions related to image processing techniques for front-projected vision-based table systems, including a shadow-based touch detection algorithm, a fast, simple visual bar code scheme tailored to projection-vision table systems, the ability to continuously track sheets of paper, and an optical flow-based algorithm for the manipulation of onscreen objects that does not rely on fragile tracking algorithms.

The weather research and forecast model: software architecture and performance

Abstract: The first non-beta release of the Weather Research and Forecast (WRF) modeling system in May, 2004 represented a key milestone in the effort to design and implement a fullyfunctioning, next-generation modeling system for the atmospheric research and operational NWP user communities. With efficiency, portability, maintainability, and extensibility as bedrock requirements, the WRF software framework has allowed incremental and reasonably rapid development while maintaining overall consistency and adherence to the architecture and its interfaces. The WRF 2.0 release supports the fullrange of functionality envisioned for the model including efficient scalable performance on a range of high-performance computing platforms, multiple dynamic cores and physics options, low-overhead two-way interactive nesting, moving nests, model coupling, and interoperability with other common model infrastructure efforts such as ESMF.

The Model Coupling Toolkit: A New Fortran90 Toolkit for Building Multiphysics Parallel Coupled Models

Abstract: Many problems in science and engineering are best simulated as a set of mutually interacting models, resulting in a coupled or multiphysics model. These models present challenges stemming from their interdisciplinary nature and from their computational and algorithmic complexities. The computational complexity of individual models, combined with the popularity of the distributed-memory parallel programming model used on commodity micro-processor-based clusters, results in a parallel coupling problem when building a coupled model. We define and elucidate this problem and how it results in a set of requirements for software capable of simplifying the construction of parallel coupled models. We describe the package, the Model Coupling Toolkit (MCT), which we have developed to meet these general requirements and the specific requirements of a parallel climate model. We present the MCT programming model with illustrative code examples. We present representative results that measure MCT's scalability, performance portability, and a proxy for coupling overhead.

The Planet Simulator: Towards a user friendly model

Abstract: The Planet Simulator is a Model of Intermediate Complexity (MIC) which can be used to run climate and paleo-climate simulations for time scales up to 10 thousand years or more in an acceptable real time. The priorities in development are set to speed, easy handling and portability. Its modular structure allows a problem dependent configuration. Adaptions exist for the atmospheres of Mars and of Saturn’s moon Titan. Common coupling interfaces enable the addition of ocean models, ice models, vegetation and more. An interactive mode with a Model Starter (MoSt) and a Graphical User Interface (GUI) can be used to select a model configuration from the available hierarchy, set its parameters and inspect atmosphericfields while changing model parameters on the fly. This is especially useful for teaching, debugging and tuning of parameterizations. This paper gives an overview of the model’s features. The complete model including sources and documentation is available at (www.mi.uni-hamburg.de/plasim). Zusammenfassung

Ibis: a flexible and efficient Java-based Grid programming environment

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.

Systems and methods for management of contact information

Abstract: Systems and methods for the management of contact information, which may include automatic transfer processes (102,103), automatic update processes, automatic customization processes, automatic delivery processes (1061,1062,1063), automatic storage processes (101), automatic portability processes (106), and/or automatic radial mining processes.

Portability regimes of pension and health care benefits for international migrants: an analysis of issues and good practices

Abstract: The paper provides a first investigation into the portability of pension and health care benefits for international migrants. It is based on available literature and newly minted data, but more importantly on selective case studies from main migrant-sending and receiving countries. While exploratory, the paper achieves a better understanding of the realities on the ground and is able to distill key issues as well as identify good and best practices. The main conclusions include the following: First, only around 20 percent of migrants worldwide work in host countries where full portability of pension benefits, but not necessarily of health care benefits, to their home countries is ensured. Second, bilateral agreements are seemingly the current best practice to ensure portability for pension and health care benefits, although for the latter this is not always the case. Third, more actuarial-type structures should help to enhance portability. This is, in principle, straightforward for pensions and a defined contribution-type design. It is much more complicated for health care benefits. Last but not least, for improved benefit design and implementation, the information base needs to be broadened, including through more country case studies and tracer studies of migrants.

Design and Implementation of Components in the Earth System Modeling Framework

Abstract: The Earth System Modeling Framework is a component-based architecture for developing and assembling climate and related models. A virtual machine underlies the component-level constructs in ESMF, providing both a foundation for performance portability and mechanisms for resource allocation and component sequencing.

Optimizing Bandwidth Limited Problems Using One-SidedCommunication and Overlap

Abstract: Partitioned Global Address Space languages like Unified Parallel C (UPC) are typically valued for their expressiveness, especially for computations with fine-grained random accesses. In this paper we show that the one-sided communication model used in these languages also has a significant performance advantage for bandwidth-limited applications. We demonstrate this benefit through communication microbenchmarks and a case-study that compares UPC and MPI implementations of the NAS Fourier Transform (FT) benchmark. Our optimizations rely on aggressively overlapping communication with computation but spreading communication events throughout the course of the local computation. This alleviates the potential communication bottleneck that occurs when the communication is packed into a single phase (e.g., the large all-to-all in a multidimensional FFT). Even though the new algorithms require more messages for the same total volume of data, the resulting overlap leads to speedups of over 1.75x and 1.9x for the two-sided and one-sided implementations, respectively, when compared to the default NAS Fortran/MPI release. Our best one-sided implementations show an average improvement of 15 percent over our best two-sided implementations. We attribute this difference to the lower software overhead of one-sided communication, which is partly fundamental to the semantic difference between one-sided and two-sided communication. Our UPC results use the Berkeley UPC compiler with the GASNet communication system, and demonstrate the portability and scalability of that language and implementation, with performance approaching 0.5TFlop/s on the FT benchmark running on 512 processors.

Acceptance of Ubiquitous Computing

Abstract: With portability similar to a spiral notebook, the tablet PC enables new ways of working This study investigates user acceptance of this new technology through interviews with employees in four industries who participated in three-month trials

Digital x-ray camera

Abstract: Portable x-ray devices and methods for using such devices are described. The devices have an x-ray tube powered by an integrated power system. The x-ray tube is shielded with a low-density insulating material containing a high-Z substance. The devices can also have an integrated display component. With these components, the size and weight of the x-ray devices can be reduced and the portability of the devices enhanced. The x-ray devices also have an x-ray detecting means that is not structurally attached to the device and therefore is free standing. Consequently, the x-ray devices can also be used as a digital x-ray camera. The portable x-ray devices are especially useful for applications where portability is an important feature such as in field work, remote operations, and mobile operations such as nursing homes, home healthcare, or teaching classrooms. This portability feature can be particularly useful in multi-suite medical and dental offices where a single x-ray device can be used as a digital x­ray camera in multiple offices instead of requiring a separate device in every office.

Parrot: Transparent User-Level Middleware for Data-Intensive Computing

Abstract: Distributed computing continues to be an alphabet-soup of services and protocols for managing computation and storage. To live in this environment, applications require middleware that can transparently adapt standard interfaces to new distributed systems; such middleware is known as an interposition agent. In this paper, we present several lessons learned about interposition agents via a progressive study of design possibilities. Although performance is an important concern, we pay special attention to less tangible issues such as portability, reliability, and compatibility. We begin with a comparison of seven methods of interposition and select one method, the debugger trap, that is the slowest but also the most reliable. Using this method, we implement a complete interposition agent, Parrot, that splices existing remote I/O systems into the namespace of standard applications. The primary design problem of Parrot is the mapping of fixed application semantics into the semantics of the available I/O systems. We offer a detailed discussion of how errors and other unexpected conditions must be carefully managed in order to keep this mapping intact. We conclude with a evaluation of the performance of the I/O protocols employed by Parrot, and use an Andrew-like benchmark to demonstrate that semantic differences have consequences in performance.

Flexible hardware abstraction for wireless sensor networks

Abstract: We present a flexible hardware abstraction architecture (HAA) that balances conflicting requirements of wireless sensor networks (WSNs) applications and the desire for increased portability and streamlined development of applications. Our three-layer design gradually adapts the capabilities of the underlying hardware platforms to the selected platform-independent hardware interface between the operating system core and the application code. At the same time, it allows the applications to utilize a platform's full capabilities-exported at the second layer, when the performance requirements outweigh the need for cross-platform compatibility. We demonstrate the practical value of our approach by presenting how it can be applied to the most important hardware modules that are found in a typical WSN platform. We support our claims using concrete examples from existing hardware abstractions in TinyOS and our implementation of the MSP430 platform that follows the architecture proposed in this paper.

RC-BLAST: towards a portable, cost-effective open source hardware implementation

Abstract: Basic Local Alignment Search Tool (BLAST) is a standard computer application that molecular biologists use to search for sequence similarity in genomic databases. This paper describes the implementation of an FPGA-based hardware implementation designed to accelerate the BLAST algorithm. FPGA-based custom computing machines, more widely known as reconfigurable computing, are supported by a number of vendors and the basic cost of FPGA hardware is dramatically decreasing. Hence, the main objective of this project is to explore the feasibility of using this new technology to realize a portable, open source FPGA-based accelerator for the BLAST algorithm. The present design is targeted to an AceIIcard and the design is based on the latest version of BLAST available from NCBI. Since the entire application does not fit in hardware, a profile study was conducted that identifies the computationally intensive part of BLAST. An FPGA hardware component has been designed and implemented for this critical segment. The portability and cost-effectiveness of the design are discussed.

Communication optimizations for fine-grained UPC applications

Abstract: Global address space languages like UPC exhibit high performance and portability on a broad class of shared and distributed memory parallel architectures. The most scalable applications use bulk memory copies rather than individual reads and writes to the shared space, but finer-grained sharing can be useful for scenarios such as dynamic load balancing, event signaling, and distributed hash tables. In this paper we present three optimization techniques for global address space programs with fine-grained communication: redundancy elimination, use of split-phase communication, and communication coalescing. Parallel UPC programs are analyzed using static single assignment form and a dataflow graph, which are extended to handle the various shared and private pointer types that are available in UPC. The optimizations also take advantage of UPC's relaxed memory consistency model, which reduces the need for cross thread analysis. We demonstrate the effectiveness of the analysis and optimizations using several benchmarks, which were chosen to reflect the kinds of finegrained, communication-intensive phases that exist in some larger applications. The optimizations show speedups of up to 70% on three parallel systems, which represent three different types of cluster network technologies.

Practical performance portability in the Parallel Ocean Program (POP)

Abstract: The design of the Parallel Ocean Program (POP) is described with an emphasis on portability. Performance of POP is presented on a wide variety of computational architectures, including vector archi...

Seamless hardware-software integration in reconfigurable computing systems

Abstract: Ideally, reconfigurable-system programmers and designers should code algorithms and write hardware accelerators independently of the underlying platform. To realize this scenario, the authors propose a portable, hardware-agnostic programming paradigm, which delegates platform-specific tasks to a system-level virtualization layer. This layer supports a chosen programming model and hides platform details from users much as general-purpose computers do. We introduce multithreaded programming model for reconfigurable computing based on a unified virtual-memory image for both software and hardware application parts. We also address the challenge of achieving seamless hardware-software interfacing and portability with minimal performance penalties.

Design and implementation of a parallel performance data management framework

Abstract: Empirical performance evaluation of parallel systems and applications can generate significant amounts of performance data and analysis results from multiple experiments as performance is investigated and problems diagnosed. Hence, the management of performance information is a core component of performance analysis tools. To better support tool integration, portability; and reuse, there is a strong motivation to develop performance data management technology that can provide a common foundation for performance data storage, access, merging, and analysis. This paper presents the design and implementation of the performance data management framework (PerfDMF). PerfDMF addresses objectives of performance tool integration, interoperation, and reuse by providing common data storage, access, and analysis infrastructure for parallel performance profiles. PerfDMF includes an extensible parallel profile data schema and relational database schema, a profile query and analysis programming interface, and an extendible toolkit for profile import/export and standard analysis. We describe the PerfDMF objectives and architecture, give detailed explanation of the major components, and show examples of PerfDMF application.

PerfSuite: An Accessible, Open Source Performance Analysis Environment for Linux

Abstract: The motivation, design, implementation, and current status of a new set of software tools called PerfSuite that is targeted to performance analysis of user applications on Linux-based systems is described. These tools emphasize ease of use/deployment and portability/reuse in implementation details as well as data representation and format. After a year of public beta availability and production deployment on Linux clusters that rank among the largest-scale in the country, PerfSuite is gaining acceptance as a user-oriented and flexible software tool set that is as valuable on the desktop as it is on leading-edge terascale clusters.

Ibis: a flexible and efficient Java-based Grid programming environment: Research Articles

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.

Biomedical information extraction with predicate-argument structure patterns

Abstract: Due to the ever growing amount of publications, Information Extraction (IE) from text is increasingly is recognized as one of crucial technologies in bioinformatics. However, for IE to be practically applicable, adaptability/portability of a system is crucial, considering extremely diverse demands in biomedical IE application. We should be able to construct a set of “extraction rules” adapted for a specific application at low

BioLayout(Java): versatile network visualisation of structural and functional relationships.

Abstract: Visualisation of biological networks is becoming a common task for the analysis of high-throughput data. These networks correspond to a wide variety of biological relationships, such as sequence similarity, metabolic pathways, gene regulatory cascades and protein interactions. We present a general approach for the representation and analysis of networks of variable type, size and complexity. The application is based on the original BioLayout program (C-language implementation of the Fruchterman-Rheingold layout algorithm), entirely re-written in Java™ to guarantee portability across platforms. BioLayoutJava provides broader functionality, various analysis techniques, extensions for better visualisation and a new user interface. Examples of analysis of biological networks using BioLayoutJava are presented.

Trickle: a userland bandwidth shaper for Unix-like systems

Abstract: As with any finite resource, it is often necessary to apply policies to the shared usage of network resources. Existing solutions typically implement this by employing traffic management in edge routers. However, users of smaller networks regularly find themselves in need of nothing more than ad-hoc rate limiting. Such networks are typically unmanaged, with no network administrator(s) to manage complicated traffic management schemes. Trickle bridges this gap by providing a simple and portable solution to rate limit the TCP connections of a given process or group of processes. Trickle takes advantage of the Unix dynamic loader's preloading functionality to interposition itself in front of the BSD socket API provided by the system's libc. Running entirely in user space, shapes network traffic by delaying and truncating socket I/Os without requiring administrator privileges. Instances of Trickle can cooperate, even across networks allowing for the specification of global rate limiting policies. Due to the prevalence of BSD sockets and dynamic loaders, Trickle enjoys the benefit of portability accross a multitude of Unix-like platforms.

Parallel VSIPL++: An Open Standard Software Library for High-Performance Parallel Signal Processing

Abstract: Real-time signal processing consumes the majority of the world's computing power. Increasingly, programmable parallel processors are used to address a wide variety of signal processing applications (e.g., scientific, video, wireless, medical, communication, encoding, radar, sonar, and imaging). In programmable systems, the major challenge is no longer hardware but software. Specifically, the key technical hurdle lies in allowing the user to write programs at high level, while still achieving performance and preserving the portability of the code across parallel computing hardware platforms. The Parallel Vector, Signal, and Image Processing Library (Parallel VSIPL++) addresses this hurdle by providing high-level C++ array constructs, a simple mechanism for mapping data and functions onto parallel hardware, and a community-defined portable interface. This paper presents an overview of the Parallel VSIPL++ standard as well as a deeper description of the technical foundations and expected performance of the library. Parallel VSIPL++ supports adaptive optimization at many levels. The C++ arrays are designed to support automatic hardware specialization by the compiler. The computation objects (e.g., fast Fourier transforms) are built with explicit setup and run stages to allow for runtime optimization. Parallel arrays and functions in Parallel VSIPL++ also support explicit setup and run stages, which are used to accelerate communication operations. The parallel mapping mechanism provides an external interface that allows optimal mappings to be generated offline and read into the system at runtime. Finally, the standard has been developed in collaboration with high performance embedded computing vendors and is compatible with their proprietary approaches to achieving performance.

Method and system for seamless portability by profile sharing

Abstract: A framework (10) and method (60 and 70) of collectively setting preferences among at least two electronic devices (52 and 54) can include the step of collecting user preference data independently by the at least two electronic devices, exchanging (65 and 75) the user preference data among the at least two electronic devices when such devices are within a predetermined proximity (63 and 73), forming a user profile (82) from the user data exchanged, and setting parameters (47) in at least one among the electronic devices in accordance with the user profile. The method can further include the steps of authenticating the at least two electronic devices before the step of exchanging the user preference data and registering users. The method can also further include the step of interchanging capabilities and settings among the at least two devices.

Overview of the Software Design of the Community Climate System Model

Abstract: The Community Climate System Model (CCSM) is a computer model for simulating the Earth's climate. The CCSM is built from four individual component models for the atmosphere, ocean, land surface, and sea ice. The notion of a physical/dynamical component of the climate system translates directly to the software component structure. Software design of the CCSM is focused on the goals of modularity, extensibility, and performance portability. These goals are met at both the component level and within the individual component models. Performance portability is the ability of a code to achieve good performance across a variety of computer architectures while maintaining a single source code. As a community model, the CCSM must run on a variety of machine architectures and must perform well on all these architectures for computationally intensive climate simulations.

Portable x-ray device

Abstract: Portable x-ray devices and methods for using such devices are described. The devices have an x-ray tube (30) powered by an integrated power system (40). The x-ray tube is shielded with a low-density insulating material (80) containing a high-Z substance. The devices can also have an integrated display component (70). With these components, the size and weight of the x-ray devices can be reduced, and the portability of the devices enhanced. Thus, the portable x-ray devices are especially useful for applications where portability is an important feature such as in field work, remote operations, and mobile operations such as nursing homes, home healthcare and teaching classrooms. This portability feature can be particularly useful in multi-suite medical and dental offices where a single x-ray device can be used in multiple offices instead of single using an x-ray device in each office.

Firm-core virtual FPGA for just-in-time FPGA compilation

Abstract: Just-in-time (JIT) compilation has been used in many applications to enable standard software binaries to execute on different underlying processor architectures, yielding software portability benefits Researchers previously introduced the concept of a standard hardware binary to achieve similar portability benefits for hardware, using a JIT compiler to compile the hardware binary to an FPGA The JIT compiler includes lean versions of technology mapping, placement, and routing algorithms that implement the standard hardware binary on a simple custom FPGA fabric designed specifically for JIT compilation While developing a custom FPGA may be feasible for some applications, we propose implementing the simple FPGA fabric as a virtual FPGA In this paper, we present a virtual FPGA, described using structural VHDL and thus representing a firm core that a designer can synthesize onto an existing FPGA We synthesized the firm-core virtual FPGA onto Xilinx Spartan physical FPGAs and then mapped 18 benchmark circuits onto the virtual FPGA Our results show a 6X decrease in performance and 100x more hardware resource usage, for the virtual FPGA approach compared to mapping the circuits directly to the physical FPGA fabric While the hardware overhead is large, large commercial FPGA capacities may still mean that some applications can utilize a virtual FPGA approach if portability is more important than resource utilization Furthermore, our work provides a baseline for future virtual FPGA approaches that may reduce the performance or area overhead through various means