Java based replicated server objects and their remote method invocations in a distributed environment

A distributed system is said to be fault‐tolerant if it is able to provide important services despite partial failures of the computers or software objects in the system. These systems are needed to support applications such as remote access and control, virtual mobile offices and wide area collaborative systems where there are chances of failures in the network and software objects. Fault‐tolerance is usually achieved by replicating the objects in the system. Traditional distributed applications constructed using Java RMI (remote method invocation) are not fault‐tolerant because of the lack of support of object replication. The objective of the present work is to design a remote method invocation that supports server object replication. To provide a fault‐tolerant service to the remote client objects, server objects are actively replicated. The problems associated with the method invocation in the context of active server object replication are presented and solutions are discussed and implemented. Copyright © 2001 John Wiley & Sons, Ltd.     

分布式PowerBuilder设计

本文以开发实例的形式,介绍了在分布式计算方法和三级系统结构下,PowerBuilder分布式应用的主要组成,即主要由数据库服务器、应用服务器（远程对象、服务器接口）和客户端程序（远程对象代理、客户端接口、用户界面）组成。实现了几乎所有的商业逻辑都在应用服务器中实现,前台程序只是通过应用服务器提供的接口来实现其功能的特性。     

A Library for Developing PHIGS Programming Tools in a PEX Environment

The merger of three-dimensional graphics with the X Window System has recently been standardized by adapting PHIGS, the Programmer's Hierarchical Interactive Graphics System, to the X Window System with PEX, the PHIGS Extension to X. The standard programming library for PEX has been defined to be identical to PHIGS PLUS allowing PHIGS programs to port directly to the X environment. X uses a client server model to run applications as client processes which communicate with a server to perform graphical display and input. For improved performance, the PEX extension defines new server resources to reduce network traffic and to take advantage of graphics hardware existing on high-end servers. A side effect of this distributed model of computation is a distribution of PHIGS structures leading to a relaxation of the exclusive access which a PHIGS application usually maintains over its Central Structure Store. We exploit the distributed nature of a PEX/PHIGS client's Central Structure Store to provide access to it for other applications besides the originating PEX/PHIGS client. We refer to these other applications as tools since one of our primary goals is to create development tools for PHIGS programmers. Rather than concentrate on particular debugging tools, we focus upon easing the process of actually developing tools. Our goal is to supply a collection of routines which can be used by PHIGS programmers to create custom tools or other programs which require access to the graphics data of remote PHIGS processes. Our Tool Development Library provides the PHIGS programmer a small number of management routines which orchestrate the connection and mapping to the data of one or more remote PHIGS applications. Manipulation of remote PHIGS structures is accomplished just as easily as local operations and is performed using standard PHIGS calls. The remote application being accessed requires no changes to its source code. Obvious uses for the Tool Development Library are in the construction of PHIGS tools such as structure browsers, editors and debugging aids. Less obvious is the potential for developing collections of cooperating graphics applications which share graphics data.     

A middleware architecture to facilitate distributed programming: DAROC: Data-Activated Replicated Object Communications

Programming distributed computer systems is difficult because of complexities in addressing remote entities, message handling, and program coupling. As systems grow, scalability becomes critical, as bottlenecks can serialize portions of the system. When these distributed system aspects are exposed to programmers, code size and complexity grow, as does the fragility of the system. This paper describes a distributed software architecture and middleware implementation that combines object-based blackboard-style communications with data-driven and periodic application scheduling to greatly simplify distributed programming while achieving scalable performance. Data-Activated Replication Object Communications (DAROC) allows programmers to treat shared objects as local variables while providing implicit communications.     

Applications of dynamic proxies in distributed environments

In object‐oriented programming (OOP), proxies are entities that act as an intermediary between client objects and target objects. Dynamic proxies can be used to construct distributed systems that support the open implementation approach and promote code reuse. The OO paradigm supports code reuse through various ways including inheritance, polymorphism and aggregation. In this paper, we adopt a definition of software reuse restricted to reuse of code components and address the question of constructing distributed systems based on dynamic proxies. Different networking techniques and programming paradigms such as Java's Remote Method Invocation (RMI), the Common Object Request Broker Architecture (CORBA) and Java Servlets are used to implement the distributed client/server architecture. Copyright © 2004 John Wiley & Sons, Ltd.     

MaDViWorld: a software framework for massively distributed virtual worlds

The MaDViWorld project represents an original attempt to define an appropriate software architecture for supporting massively distributed virtual world systems. A non‐massively distributed virtual world system is typically engineered as a client–server application for which a single server or more rarely a small cluster of servers contain all the world pertinent data and assume the world accessibility, consistency and persistence. On the client side, many of them enable interaction with the other users and the various objects of the world. The main originality of our approach resides in the fact that the server part of the proposed system is no more limited to a few centralized servers, but can be distributed on arbitrarily many of them. Indeed, MaDViWorld, the prototypal software framework already implemented using Java and RMI by our group, allows for creating the rooms of a given world on several machines, each running the server application. It is then possible to connect the rooms by way of simple doors and to populate them with active objects. Finally, avatars managed by the client application visit the rooms and interact with the active objects either directly on the remote host or locally by cloning or transporting them first to the client machine. This paper draws from the experience gained with the development of our first prototype in order to discuss, both at the user's and the vi‐world developer's level, the main software engineering issues related to the implementation of such massively distributed virtual world systems. Copyright © 2002 John Wiley & Sons, Ltd.     

Object‐oriented distributed computing based on remote class reference

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.     

A computation offloading scheme on handheld devices

In this paper, we present a computation offloading scheme on handheld devices. This scheme partitions an ordinary program into a client–server distributed program, such that the client code runs on the handheld device and the server code runs on the server. Our partition analysis and program transformation guarantee correct distributed execution under all possible execution contexts. We give a polynomial time algorithm to find the optimal program partition for given program input data. We use an option-clustering approach to handle different program partitions for different program execution options. Experimental results show significant improvement of performance and energy consumption on an HP IPAQ handheld device through computation offloading.     

Web/Native混合软件体系结构研究

文章提出了一种Web/Native混合软件体系结构。通过在传统C/S结构的客户端软件中集成Web浏览器引擎,使得客户端软件既具有对硬件设备的全面控制能力,又具有与Web应用相同的灵活性。基于该架构开发的数字证书客户端管理软件,可以通过对Web服务器端代码实时动态的调整来控制客户端软件的用户界面和业务逻辑,满足数字证书运营商越来越复杂多变的业务需求。     

On‐demand transmission model for remote visualization using image‐based rendering

Interactive distributed visualization is an emerging technology with numerous applications. However, many of the present approaches to interactive distributed visualization have limited performance because they are based on the traditional polygonal processing graphics pipeline. In contrast, image‐based rendering uses multiple images of the scene instead of a three‐dimensional geometrical representation, and so has the key advantage that the final output is independent of the scene complexity and depends on the desired final image resolution. Furthermore, the discrete nature of the light field dataset maps well to a hybrid solution, which can overcome the identified drawbacks. In this paper, we propose an on‐demand solution for efficiently transmitting visualization data to remote users/clients. This is achieved through sending selected parts of the dataset based on the current client viewpoint, and is done instead of downloading a complete replica of the light field dataset to each client, or remotely sending a single rendered view back from a central server to the user each time the user updates their viewing parameters. The on‐demand approach shows stable performance as the number of clients increases because the load on the server and the network traffic are reduced. Furthermore, detailed performance studies show that the proposed scheme outperforms the current solution in terms of interactivity measured in frames per second. Copyright © 2012 John Wiley & Sons, Ltd.     

Object and process migration in a single-address-space distributed system

In a distributed system framework, program interactions can be modelled by using typed objects according to client/server relationships. The operations defined by a given type are the services that may be provided by an object of this type to a client process. When the process and the object are located in different nodes, migrations may represent valid alternatives to remote procedure calls. Migration of the server object causes the memory area storing the internal representation of this object to be copied into the node of the client process. Migration of the client process causes execution of this process to proceed in the node of the server object. This paper proposes migration paradigms with reference to a memory environment implementing the notion of a single address space. The discussion takes a number of salient issues into consideration, including performance, memory configurations for object storage, and the strategies for memory management.     

基于Java的远程文件管理系统的设计与实现

为了实现远程文件管理系统的跨操作系统运行,设计了一套基于Java Socket的远程文件类应用程序接口(API),并在这套API的基础上实现了一个图形界面的Client／Server结构的远程文件管理系统。这套API在形式上类似于Sun JDK本地文件类,开发人员使用这套API能方便快速地实现能满足自身需要的远程文件管理系统。     

基于Web远程文件管理系统的java实现

为了实现远程文件管理系统的跨操作系统运行,设计了一套基于Java Socket的远程文件类应用程序接口(API),并在此基础上实现了一个图形界面的Client/Server结构的远程文件管理系统。这套API在形式上类似于SunJDK本地文件类,开发人员使用这套API能方便快速地实现能满足自身需要的远程文件管理系统。     

MobileRMI: upgrading Java Remote Method Invocation towards mobility

Code mobility is recognized as a promising design technique, able to improve flexibility, adaptability and bandwidth utilization in mobile computing applications. To promote and facilitate its use, researchers argue that code mobility should be made available to programmers in combination with, and not as an alternative to, more traditional programming models. This paper describes the design and implementation of the MobileRMI toolkit which, unlike agent-based systems, enables mobility-based programming within a widely accepted middleware platform, Java Remote Method Invocation (RMI). Our toolkit provides a set of mobility primitives that allow programmers to create, clone and move remote objects across a network. To preserve location transparency we implemented a novel, efficient scheme for automatically updating remote references by exploiting the distributed garbage collector. Programming examples are given and a case study where an adaptive application uses logical mobility to minimize communication over a mobile ad hoc network is presented. Experience from using MobileRMI confirmed the benefit of designing both static and mobile applications within the same programming framework. Copyright © 2005 John Wiley & Sons, Ltd.     

Client ahead‐of‐time compiler for embedded Java platforms

Many embedded Java platforms execute two types of Java classes: those installed statically on the client device and those downloaded dynamically from service providers at run time. For achieving higher performance, the static Java classes can be compiled into machine code by ahead‐of‐time compiler (AOTC) in the server, and the translated machine code can be installed on the client device. Unfortunately, AOTC cannot be applicable to the dynamically downloaded classes. This paper proposes client‐AOTC (c‐AOTC), which performs AOTC on the client device using the just‐in‐time compiler (JITC) module installed on the device, obviating the JITC overhead and complementing the server‐AOTC. The machine code of a method translated by JITC is cached on a persistent memory of the device, and when the method is invoked again in a later run of the program, the machine code is loaded and executed directly without any translation overhead. A major issue in c‐AOTC is relocation because some of the address constants embedded in the cached machine code are not correct when the machine code is loaded and used in a different run; those addresses should be corrected before they are used. Constant pool resolution and inlining complicate the relocation problem, and we propose our solutions. The persistent memory overhead for saving the relocation information is also an issue, and we propose a technique to encode the relocation information and compress the machine code efficiently. We developed a c‐AOTC on Sun's CDC VM reference implementation, and our evaluation results indicate that c‐AOTC can improve the performance significantly, as much as an average of 12% for EEMBC and 4% for SpecJVM98, with a persistent memory overhead of 1% on average. Copyright © 2008 John Wiley & Sons, Ltd.     

Parallel Array Object I/O Support on Distributed Environments

This paper presents a parallel file object environment to support distributed array store on shared-nothing distributed computing environments. Our environment enables programmers to extend the concept of array distributions from memory levels to file levels. It allows parallel I/O that facilitates the distribution of objects in an application. When objects are read and/or written by multiple applications using different distributions, we present a novel scheme to help programmers to select the best data distribution pattern according to a minimum amount of remote data movements for the store of array objects on distributed file systems. Our selection scheme, to the best of our knowledge, is the first work to attempt to optimize the distribution patterns in the secondary storage for HPF-like programs with inter-application cases. This is especially important for a class of problems called multiple disciplinary optimization (MDO) problems. Our test bed is built on an 8-node DEC Farm connected with an ethernet, FDDI, or ATM switch. Our experimental results with scientific applications show that not only our parallel file system can provide aggregate bandwidths, but also our selection scheme effectively reduces the communication traffic for the system.     

基于Internet的直接网络数据服务的基本概念与技术框架

直接网络数据服务为计算程序提供了一种通过Internet直接访问远程数据的手段 ,它在通讯和计算技术上分别以SOAP协议和Java跨平台计算能力为基础。本文分析了Internet应用技术的现状和发展 ,结合当前数据交换技术和化工数据应用的特点 ,提出了一种新的化工数据应用方法 ,即建立基于Internet的直接网络数据服务的计算模型。实现此计算体系涉及多方面的数据协议和计算技术 ,其中最重要的思想是通过构建一个易用的数据规范框架 ,以简化整个体系的用户使用界面 (包括编程接口和访问语法 )。该框架定义了数据的描述规范、存储规范、查询规范、传输规范和使用规范。该计算模型主要包括 3个部分 ,即服务器端的数据库模型、基于SOAP的数据传输模型和客户端的应用编程接口。该系统以远程程序为数据消费对象 ,最终将实现对数据库透明的访问能力和可扩充的分布服务能力。在此基础上 ,可以进一步发展为分布式计算服务体系     

采用新的流调度策略的视频点播系统研究

客户多播补块流调度策略——CMP(Client Multicast Patching)——是基于代理缓存的有效的视频点播策略，它采用用户参与流调度的方式，某些用户在播放节目的同时，又作为服务器为后续用户多播一部分节目，因此，在不增加用户I／O带宽的前提下，通过利用局域网络丰富的带宽．有效地节省了服务器及主干网络的资源，并对用户请求提供即时服务，该文给出CMP方案的实现算法，并对系统进行仿真及性能分析，结果表明了CMP方案的有效性和可行性。     

Fuzzy service selection in a distributed object-orientedenvironment

In network-centered execution environments, client objects can transparently invoke services offered by remote server objects, according to their published interface. The object selection problem requires the evaluation of the fitness of a pool of candidate server objects on the basis of the available information about their functional and nonfunctional features. Network-centered systems usually store such information in a trader agent that can be browsed or queried by client objects. In this paper, a fuzzy data model is proposed as the basis of the design of such a trader system, taking into account synergy between objects' features. Our trader is based on a fuzzy query algebra allowing for deriving operator definitions (therefore, query execution mechanisms) at run time, on the basis of user-selected semantics     

云应用管理引擎的设计与实现

介绍了云应用管理引擎的设计思想与实现方式,以解决传统上应用程序必须安装在本地才能运行的问题.云应用管理引擎对安装在Windows或Linux应用服务器上的应用程序进行管理,在集群范围或服务器范围内将应用程序发布为远程应用,并将远程应用授权给用户.授权用户可以从各种客户端设备和系统运行交付给自己的远程应用程序,就像运行本地应用程序一样.