Showing papers on "Software portability published in 2001"

Recent advances in augmented reality

Abstract: In 1997, Azuma published a survey on augmented reality (AR). Our goal is to complement, rather than replace, the original survey by presenting representative examples of the new advances. We refer one to the original survey for descriptions of potential applications (such as medical visualization, maintenance and repair of complex equipment, annotation, and path planning); summaries of AR system characteristics (such as the advantages and disadvantages of optical and video approaches to blending virtual and real, problems in display focus and contrast, and system portability); and an introduction to the crucial problem of registration, including sources of registration error and error-reduction strategies.

An architecture for more realistic conversational systems

Abstract: In this paper, we describe an architecture for conversational systems that enables human-like performance along several important dimensions. First, interpretation is incremental, multi-level, and involves both general and task- and domain-specific knowledge. Second, generation is also incremental, proceeds in parallel with interpretation, and accounts for phenomena such as turn-taking, grounding and interruptions. Finally, the overall behavior of the system in the task at hand is determined by the (incremental) results of interpretation, the persistent goals and obligations of the system, and exogenous events of which it becomes aware. As a practical matter, the architecture supports a separation of responsibilities that enhances portability to new tasks and domains.

Method and apparatus for a product lifecycle management process

Abstract: Techniques, methods, systems and system components facilitate new product development and product lifecycle management in an enterprise. According to a specific embodiment, the invention provides a networked-enabled development software engine that assists users coordinate and keep track of progress and status of development activities. A unifying structure for Business Objects allows the software engine to provide a number of integrated cross-program functions, such as portfolio review and automated resource assignment and allows object portability and allows new objects to be more easily created from old objects.

Titanium Language Reference Manual

Abstract: Titanium is a dialect of Java for large-scale scientific computing. The primary goal is a language that has high performance on large scale multiprocessors, including massively parallel processors and workstation clusters with one or more processors per node. Secondary goals include safety, portability, and support for building complex data structures. The main additions to Java are immutable classes, multi-dimensional arrays, an explicitly parallel SPMD model, and zone-based memory management. This document informally describes our current design for the Titanium language. It is in the form of a set of changes to Java, version 1.0.

Preference portability for computing

Abstract: The present invention uses a portable memory device to directly or wirelessly interact with one or more host computing devices to provide a customized configuration for one or more aspects associated with a computing session. In particular, software on the portable device will automatically execute on the host computing device after the host computing device recognizes the presence of the portable device. The software provides instructions for the host computing device to launch a select program on the host computing device and provide a customized configuration for the program. The customized configuration is based on information stored on the portable device. As such, the portable device may automatically set preferred interface or program configurations personalized to the user. For example, the interface settings for a desktop, productivity, or browser application may be tailored as defined by information stored on the portable device. Other settings, such as bookmarks for a browser, may be stored on the portable device and made available to the program launched on the host computing device.

Portable resource control in Java

Abstract: Preventing abusive resource consumption is indispensable for all kinds of systems that execute untrusted mobile coee, such as mobile object sytems, extensible web servers, and web browsers. To implement the required defense mechanisms, some support for resource control must be available: accounting and limiting the usage of physical resources like CPU and memory, and of logical resources like threads. Java is the predominant implementation language for the kind of systems envisaged here, even though resource control is a missing feature on standard Java platforms. This paper describes the model and implementation mechanisms underlying the new resource-aware version of the J-SEAL2 mobile object kernel. Our fundamental objective is to achieve complete portability, and our approach is therefore based on Java bytecode transformations. Whereas resource control may be targeted towards the provision of quality of service or of usage-based billing, the focus of this paper is on security, and more specificlly on prevention of denial-of-service attacks orginating from hostile or poorly implemented mobile code.

Method, apparatus, and medium using a master control file for computer software interoperability between disparate operating systems

Abstract: A master control file enables application software to be ported between disparate operating systems of a computer without being updated by interfacing to portability enabling software, which interfaces with the disparate operating systems. Moreover, the application software includes medical software ported to a pocket device using the portability enabling software and the master control file.

The GridPort toolkit: a system for building Grid portals

Abstract: Grid portals are emerging as convenient mechanisms for providing the scientific community with familiar and simplified interfaces to the Grid. Our experience in implementing Grid portals has led to the creation of GridPort: a unique, layered software system for building Grid portals. This system has several unique features: the software is portable and runs on most Web servers; written in Perl/CGI, it is easy to support and modify; it is flexible and adaptable; it supports single login between multiple portals; and portals built with it may run across multiple sites and organizations. The feasibility of this portal system has been successfully demonstrated with the implementation of several application portals. We describe our experiences in building this system, including philosophy and design choices. We explain the toolkits we are building, and we demonstrate the benefits of this system with examples of several production portals. Finally, we discuss our experiences with Grid web service architectures.

The architecture of the Remos system

Abstract: Remos provides resource information to distributed applications. Its design goals of scalability, flexibility, and portability are achieved through an architecture that allows components to be positioned across the network, each collecting information about its local network. To collect information from different types of networks and from hosts on those networks, Remos provides several collectors that use different technologies, such as SNMP or benchmarking. By matching the appropriate collector to each particular network environment and by providing an architecture for distributing the output of these collectors across all querying environments, Remos collects appropriately detailed information at each site and distributes this information where needed in a scalable manner. Prediction services are integrated at the user-level, allowing history-based data collected across the network to be used to generate the predictions needed by a particular user. Remos has been implemented and tested in a variety of networks and is in use in a number of different environments.

Adaptive scheduling of master/worker applications on distributed computational resources

Abstract: One of the most popular ways to implement parallel operations on distributed-memory architectures is with a Master-Worker (MW) organization that concentrates control functions within a single master process, and delegates responsibility for computations to remote worker processes. While the MW approach is conceptually simple to put in practice, achieving consistent portable performance over a wide range of available distributed computing environments requires a variety of scheduling capabilities and techniques that allow application behavior to be tailored to fit specific environmental conditions. This dissertation addresses problems in simultaneously achieving MW application performance, portability, and ease of development. Application performance is determined by the combination of specific application requirements and the available capacity of system resources to meet those needs. This dissertation presents a work-flow model of MW application performance that correctly accounts for both computation and communication-based performance constraints. Using this work-flow model, we have developed a resource selection algorithm for choosing appropriate hosts for master and worker processes that delivers performance up to levels allowed by application-specific constraints. Application portability is essential for ensuring that a wide array of platforms are available to users as targets for individual MW applications. Instead of simply providing portability by reducing available capabilities to a least common denominator, we present an AppLeS Master Worker Application Template (AMWAT) approach to developing MW applications that maximizes program portability while also providing access to unique resource capabilities and specialized scheduling techniques. We present a variety of basic and specialized scheduling techniques for MW applications, and then experimentally show how different techniques are appropriate in specific scheduling regimes. In particular, the effectiveness of different work distribution strategies are experimentally compared for a set of test applications and environmental conditions. We have incorporated each of the scheduling techniques into a portable reusable performance-oriented scheduler module. Ease of MW application development is specifically addressed in the AMWAT approach. Rather than have every MW application implement many different common functions, we show how MW development can be simplified by separating functions provided by common components, such as the general scheduler module, from purely application-specific functionality.

The hyperion system: compiling multithreaded java bytecode for distributed execution

Abstract: Our work combines Java compilation to native code with a runtime library that executes Java threads in a distributed memory environment. This allows a Java programmer to view a cluster of processors as executing a single JAVA virtual machine. The separate processors are simply resources for executing Java threads with true parallelism, and the run-time system provides the illusion of a shared memory on top of the private memories of the processors. The environment we present is available on top of several UNIX systems and can use a large variety of communication interfaces thanks to the high portability of its run time system. To evaluate our approach, we compare serial C, serial Java, and multithreaded Java implementations of a branch and-bound solution to the minimal-cost map-coloring problem. All measurements have been carried out on two platforms using two different communication interfaces: SISCI/SCI and MPI BIP/Myrinet.

Methods and systems for providing universal triggerless number portability

Abstract: A universal triggerless number portability routing node receives a first call setup message from an end office. The triggerless number portability routing node may examine a first routing number (RN) value contained in the first call setup message to determine whether the first RN is a home RN value. If the first RN is determined to be a home RN value, a number portability database lookup is performed based on the called party dialed number. Once a number portability lookup is performed, the call setup message is modified to include a second RN value returned by the NP database, and the modified call setup message is routed to a destination node, which may be a tandem gateway or an end office/mobile switching center.

Pathways of Portability: Islamic and Christian Interchange from the Tenth to the Twelfth Century

Abstract: This paper will focus on the role of the portable arts in cross-cultural interchange between Islamic and Christian realms from the tenth to the twelfth century. I will argue here for an expansion of the study of portable arts beyond the traditional focus on sites of production to the consideration of the arenas in which works were circulated and viewed. Instead of asking where objects came from, the question will be how objects were used and perceived interculturally? What were the implications of portability? Portability allowed objects to extend beyond themselves, as mediators for and as sites of interchange. I will explore how identities and the meanings of these objects – the way they were defined and redefined – were tied to and shaped by their portability.

Design and implementation of the J-SEAL2 mobile agent kernel

Abstract: J-SEAL2 is a secure, portable, and efficient execution environment for mobile agents. The core of the system is a micro-kernel fulfilling the same functions as a traditional operating system kernel: protection, communication, domain termination and resource control. This paper describes the key concepts of the J-SEAL2 micro-kernel and how they are implemented in pure Java.

Efficiency vs. portability in cluster-based network servers

Abstract: Efficiency and portability are conflicting objectives for cluster-based network servers that distribute the clients' requests across the cluster based on the actual content requested Our work is based on the observation that this efficiency vs portability tradeoff has not been fully evaluated in the literature To fill this gap, in this paper we use modeling and experimentation to study this tradeoff in the context of an interesting class of content-based network servers, the locality-conscious servers, under different inter-node communication subsystems Based on our results, our main conclusion is that portability should be promoted in cluster-based network servers with low processor overhead, given its relatively low cost ($\leq$ 16%) in terms of throughput performance For clusters with high processor overhead communication, efficiency should be the overriding concern, as the cost of portability can be very high (as high as 107% on 96 nodes) We also conclude that user-level communication can be useful even for non-scientific applications such as network servers

Eliminating redundancies in sum-of-product array computations

Abstract: Array programming languages such as Fortran 90, High Performance Fortran and ZPL are well-suited to scientific computing because they free the scientist from the responsibility of managing burdensome low-level details that complicate programming in languages like C and Fortran 77. However, these burdensome details are critical to performance, thus necessitating aggressive compilation techniques for their optimization. In this paper, we present a new compiler optimization called Array Subexpression Elimination (ASE) that lets a programmer take advantage of the expressibility afforded by array languages and achieve enviable portability and performance. We design a set of micro-benchmarks that model an important class of computations known as stencils and we report on our implementation of this optimization in the context of this micro-benchmark suite. Our results include a 125% improvement on one of these benchmarks and a 50% average speedup across the suite. Also we show a speedup of 32% improvement on the ZPL port of the NAS MG Parallel Benchmark and a 29% speedup over the hand-optimized Fortran version. Further, the compilation time is only negligibly affected.

Method and system for managing personal information

Abstract: A method and system is provided for controlling and managing the storage and retrieval of personal information in a computer network environment and that is configured for supporting any number of applications supplied by any number of vendors. An exemplary method and system can provide an open-ended capability for an individual to define, securely store, retrieve and/or modify information pertaining to the activities of the individual, such as those relating to computer access, electronic commerce or Internet based information searching, or the communication with other parties via electronic mechanisms. In addition, an exemplary method and system can provide significant improvement to prior art server-based and local client-based methodologies of managing stored information through the utilization of smart card-like devices having server-like processing capability, as well as physical security and mobility aspects provided by the size and portability of the user smart card device.

A Characterization of Temporal Locality and Its Portability across Memory Hierarchies

Abstract: This paper formulates and investigates the question of whether a given algorithm can be coded in a way efficiently portable across machines with different hierarchical memory systems, modeled as a(x)-HRAMs (Hierarchical RAMs), where the time to access a location x is a(x). The width decomposition framework is proposed to provide a machine-independent characterization of temporal locality of a computation by a suitable set of space reuse parameters. Using this framework, it is shown that, when the schedule, i.e. the order by which operations are executed, is fixed, efficient portability is achievable. We propose (a) the decomposition-tree memory manager, which achieves time within a logarithmic factor of optimal on all HRAMs, and (b) the reoccurrence-width memory manager, which achieves time within a constant factor of optimal for the important class of uniform HRAMs. We also show that, when the schedule is considered as a degree of freedom of the implementation, there are computations whose optimal schedule does vary with the access function. In particular, we exhibit some computations for which any schedule is bound to be a polynomial factor slower than optimal on at least one of two sufficiently different machines. On the positive side, we show that relatively few schedules are sufficient to provide a near optimal solution on a wide class of HRAMs.

Account portability for computing

Abstract: The present invention relates to a portable device containing software adapted to execute on and instruct a host computing device. When executing the software, the host computing device may recognize financial account fields in a web page during a browsing session and automatically fill these fields with financial account information stored on the portable device to facilitate a web-based transaction. The portable device may contain information relating to multiple financial accounts.

A PC-based software receiver using a novel front-end technology

Abstract: Since the software radio concept was introduced, much progress has been made in the past few years in making it a reality. Many software radio based systems have been designed through the development efforts of both commercial and noncommercial organizations. While the term software radio has meant many things, the ultimate goal in software radio has been the realization of an agile radio that can transmit and receive signals at any carrier frequency using any protocol, all of which can be reprogrammed virtually instantaneously. Such a system places great demands on the limits of data converter and processor technologies since it requires real-time disposition of gigasamples of data produced by direct conversion of wireless signals into digital data. From a processing standpoint, the challenge in software radio is to exploit the three basic processor types-fixed architecture processors, FPGAs, and programmable DSPs/RISCs/CISCs-in such a way as to optimize the three-way trade-offs between speed, power dissipation, and programmability. With respect to the latter characteristic, the issues of high-level language interfaces, portability, and reprogramming speed must be considered. This article describes the architecture and operation of a PC-based software radio receiver. The development environment is a real-time PC-based platform that allows testing to be done in a simple manner using the main software functionality of a PC. The front-end of the receiver implemented in hardware represents a novel wideband design (bandwidth of up to 100 MHz centered at a carrier frequency of up to 2 GHz) that functionally converts wireless signals directly into a gigasample digital data stream in the receiver (and vice versa in the transmitter). This direct conversion approach shows the greatest promise in realizing the main goal of software radio.

Semantics mapping between different object hierarchies

Abstract: To enhance portability of programming languages and compiled codes, methods and/or devices optionally compile a programming language code associated with one framework to a code associated with another framework and/or convert a code associated with one framework to a code associated with another framework. The aforementioned converters and/or methods include, but are not limited to, features for supporting framework differences in object hierarchy, exceptions, type characteristics, reflection transparency, and/or scoping.

Open Source Real Time Operating Systems Overview

Abstract: Modern control systems applications are often built on top of a real time operating system (RTOS) which provides the necessary hardware abstraction as well as scheduling, networking and other services. Several open source RTOS solutions are publicly available, which is very attractive, both from an economic (no licensing fees) as well as from a technical (control over the source code) point of view. This contribution gives an overview of the RTLinux and RTEMS systems (architecture, development environment, API etc.). Both systems feature most popular CPUs, several APIs (including Posix), networking, portability and optional commercial support. Some performance figures are presented, focusing on interrupt latency and context switching delay.

A transaction-based unified simulation/emulation architecture for functional verification

Abstract: A transaction-based layered architecture providing for 100% portability of a C-based testbench between simulation and emulation is proposed. Transaction-based communication results in performance which is commensurate with emulation without a hardware target. Testbench portability eliminates duplicated effort when combining system level simulation and emulation. An implementation based on the IKOS VStation emulator validates these architectural claims on real designs.

Shopping cart portability for computing

Abstract: The portable device of the present invention is preferably configured to facilitate a portable, electronic shopping cart capable of storing information relating to items selected during a first shopping session and make them available during a second shopping session. In particular, the portable device will include software adapted to execute on the host computing device in association with a first web-based shopping session at a first web site. When executing the software, the host computing device will store information relating to an item selected for purchase during the first web-based shopping session on the portable device for use during a second web-based shopping session. The second web-based shopping session may occur at the first web site wherein the software is adapted to instruct the host computing device to provide the information bearing on the item selected for purchase to the web site during the second web-based shopping session to facilitate purchase of the item.

Scientific Computation with JavaSpaces

Abstract: JavaSpaces provides a simple yet expressive mechanism for distributed computing with commodity technology. We discuss the suitability of JavaSpaces for implementing different classes of concurrent computations based on low-level metrics (null messaging and array I/O), and present performance results for several parametric algorithms. We found that although inefficient for communication intensive problems, JavaSpaces yields good speedups for parametric experiments, relative to both sequential Java and C. We also outline a dynamic native compilation technique, which for short, compute-intensive codes further boosts performance without compromising Java portability or extensive algorithm recoding. Discussion and empirical results are presented in the context of our public benchmark suite.

Towards a Pedagogically Sound Basis for Learning Object Portability and Re-Use.

Abstract: The issues of portability and re-use are key challenges for learning technology A major effort has been directed towards the development of standards that will enable interoperability and the re-use of ‘learning objects’ The paper provides a critique of this work from a pedagogical perspective It argues that true portability and re-use cannot be achieved based solely on a technically inspired drive towards standardization A theoretical framework is required that will guide the process of analysis and synthesis This paper proposes the basis for such a theoretical approach based on the concepts of layering and learning contexts A formal approach to capturing the essential features of these learning contexts is outlined, based on the idea of ‘design action potential’ networks The choice pathways in these networks represent a formal description that may be fed into the standardization process The ensuing descriptive data, attached as metadata to learning objects, would provide a pedagogically informed basis for interoperability and re-use

On the Effectiveness of D-BSP as a Bridging Model of Parallel Computation

Abstract: This paper surveys and places into perspective a number of results concerning the D-BSP (Decomposable Bulk Synchronous Parallel) model of computation, a variant of the popular BSP model proposed byValiant in the early nineties. D-BSP captures part of the proximity structure of the computing platform, modeling it by suitable decompositions into clusters, each characterized by its own bandwidth and latency parameters. Quantitative evidence is provided that, when modeling realistic parallel architectures, D-BSP achieves higher effectiveness and portability than BSP, without significantly affecting the ease of use. It is also shown that D-BSP avoids some of the shortcomings of BSP which motivated the definition of other variants of the model. Finally, the paper discusses how the aspects of network proximity incorporated in the model allow for a better management of network congestion and bank contention, when supporting a shared-memory abstraction in a distributed-memory environment.

Implementation of a portable software DSM in Java

Abstract: Rapid commoditization of advanced hardware and progress of networking technology is now making wide area high-performance computing a.k.a. the 'Grid' Computing a reality. Since a Grid will consist of vastly heterogeneous sets of compute nodes, especially commodity clusters, some have articulated the use of Java as a suitable technology to satisfy portability across different machines. Since Java's natural model parallelism is shared memory multithreading, one will have to support distributed shared memory (DSM) in a portable manner; however, none of the previous work on implementing Java on DSM has been a portable solution. Instead, we propose a software architecture whose goal is to achieve portability of DSM implementations across different commodity clustering platforms, while restricting the programming model somewhat, and implemented a prototype system, JDSM. Benchmark results show that the current implementation on Java incurs increased memory coherency maintenance cost compared to C-based DSMs, thus limiting scalability to some degree, and we are currently working on a solution to alleviate this cost.

Modular system for a portable communication terminal and module for use therein

Abstract: A modular system for portable multimedia communications terminal (100) has modules (110, 140, 150, 160, 170, 180, 190) that can be detachably attached together and can rotate with respect to each other and rest at any angle, so that they can arranged in a 'chain' arrangement or as a 'fan' or in any combination. There is no set limit to the number of multimedia communication modules that can be stacked together. The modules can be arranged in any order or configuration as desired by the user. This provides the advantages that: the combination of stacking and swivelling allows the device to have both compactness for portability and more "real estate" for usability; the user can choose which functionality the communication device will need to have and choose the modules (to purchase or to take out for the day) accordingly; and the keyboard modules (160, 170) 'fan' out to give a larger alpha/numeric keyboard/keypad size to increase usability.