APIs for real-time distributed object programming

Ideally, according to the author, a real-time distributed programming method should be based on a general high-level style that could be easily accommodated by application programmers using C++ and Java. If such a method were to exist, these programmers could specify the interactions among distributed components and the timing requirements of various actions without expending much effort. Facilitating high-level, high precision, real-time object programming by establishing some form of language tools has consequently become a subject of great interest to the embedded systems community. This article focuses on application programming interfaces (APIs) that take the form of C++ and Java class libraries and support high-level, high precision, real-time object programming without requiring new language translators. These APIs wrap the services of the real-time object execution engines, which consist of hardware, node OSs, and middleware; they enable convenient high-level programming almost to the extent that a new real-time object language can. The author explains the API's fundamental features, how they interact among real-time objects, and how multicast channels and real-time multicast APIs contribute     

Resource management policies for real-time Java remote invocations

A way to deal with the increasing cost of next generation real-time applications is to extend middleware and high-level general-purpose programming languages, e.g. Java, with real-time support that reduces development, deployment, and maintenance costs. In the particular path towards a distributed real-time Java technology, some important steps have been given into centralized systems to produce real-time Java virtual machines. However, the integration with traditional remote invocation communication paradigms is far from producing an operative solution that may be used to develop final products. In this context, the paper studies how The Real-Time Specification for Java (RTSJ), the leading effort in real-time Java, may be integrated with Java’s Remote Method Invocation (RMI) in order to support real-time remote invocations. The article details a specific approach towards the problem of producing a predictable mechanism for the remote invocation–the core communication mechanism of RMI–via having control on the policies used in the remote invocation. Results obtained in a software prototype help understand how the key entities defined to control the performance of the remote invocation influence in the end-to-end response time of a distributed real-time Java application.     

Qualitative and quantitative analysis and comparison of Java distributed architectures

In this article we have undertaken a qualitative and quantitative comparison of common approaches used to develop distributed solutions in Java: RMI and Web services for regular unsecured communication, RMI‐SSL and WS‐Security for secure communication and authentication, and HTTP‐to‐port and HTTP‐to‐CGI/servlet tunnelling for RMI communication through firewalls and proxies. We have performed a functional comparison that helps with the selection of the most appropriate approach. We have also carried out a detailed performance analysis with the identification of major bottlenecks, identification of design and implementation guidelines for distributed applications, and specification of optimizations for distributed middleware. This article contributes to the understanding of different approaches for developing Java distributed applications, provides detailed performance analysis, presents design and implementation guidelines, and identifies the major performance overheads. Copyright © 2006 John Wiley & Sons, Ltd.     

Scheduling of hard real-time garbage collection

Automatic memory management or garbage collection greatly simplifies development of large systems. However, garbage collection is usually not used in real-time systems due to the unpredictable temporal behavior of current implementations of a garbage collector. In this paper we propose a real-time garbage collector that can be scheduled like a normal real-time thread with a deadline monotonic assigned priority. We provide an upper bound for the collector period so that the application threads will never run out of memory. Furthermore, we show that the restricted execution model of the Safety Critical Java standard simplifies root scanning and reduces copying of static data. Our proposal has been implemented and evaluated in the context of the Java processor JOP.     

A middleware‐transparent approach to developing distributed applications

An innovative middleware‐transparent approach to developing distributed applications is presented. The approach uses an aspect‐oriented software development technique to separate an application's middleware‐independent functionality from its middleware‐specific functionality. Application elements that are specific to the middleware are localized in aspects that can be seamlessly integrated into middleware‐independent application designs. The middleware‐transparent approach is used to decouple business functionality from middleware‐specific functionality. The decoupling allows developers to change middleware application elements without significantly modifying business functionality. Middleware technologies such as Java Remote Method Invocation (RMI), Jini, Simple Object Access Protocol (SOAP) remote procedure call (RPC) and .Net are used as examples to illustrate the approach. Copyright © 2005 John Wiley & Sons, Ltd.     

Mobile Java RMI support over heterogeneous wireless networks: A case study

Distributed object-oriented platforms are increasingly important in wireless environments to provide frameworks for collaborative computation and for managing a large pool of distributed resources. One of the important layers for implementing distributed computing in such environments is via remoting mechanisms. For example, Java uses Remote Method Invocation (RMI) for handling distributed controls. In this paper, we investigate the support for this important layer on wireless environments and address the issues to support Java RMI over heterogeneous wireless environments. We present a case study for supporting Java RMI in Bluetooth, GPRS, and WLAN environments, which represents an important middleware for component communications. The Bluetooth layer is supported by incorporating a set of protocol stack layers for Bluetooth, known as JavaBT that has been developed by us, and by supporting an L2CAP layer with sockets to support Java RMI sockets. RMI over GPRS/WLAN is achieved by RMI implementation over IP layer. Our support for the roaming of Java RMI over heterogeneous wireless networks is based on the concept of direct connection, which avoids the problems caused by forwarding. The difficulty of this strategy is how to handle the existing connection when the mobile node moves to another location so as to avoid interruption of the high-level applications. We solve this problem in Java RMI by the support of dynamic addresses and dynamic sockets. We also propose algorithms to handle the handoff process. In addition, methods for connect-loss detection and data-integrity maintenance in dealing with roaming scenarios are also presented. Java Grande benchmarks are used to demonstrate that our RMI implementations over GPRS, WLAN, and Bluetooth networks are effective in supporting parallel and distributed control of Java layers in heterogeneous wireless environments.     

基于XML的分布式数据交换中间件模型设计

报告了中间件技术的现状和发展趋势，分析了分布式网络应用对主流中间件设计开发的需求，讨论了异构应用系统间在降低数据交换复杂度的基础上实现透明数据交换的可能性，研究了CORBA，XML，Java等分布式信息处理及交换技术，介绍了基于XML的分布式数据交换中间件模型的设计目标、设计内容、技术路线及可行性分析，提出一个在多应用系统间交换数据的解决方案。     

Java-centric distributed computing

The Java language and platform provide a base for distributed computing that changes several conventional assumptions. In particular, the Java Virtual Machine allows a group of Java-enabled machines to be treated as a homogeneous group rather than a heterogeneous group, despite possible differences in the machine architectures and underlying operating systems. Java also makes it possible to safely and dynamically load code in a running Java process. Together, these features allow a system to invoke methods on remote objects, which can move code associated with language-level objects from the calling process to the process called and vice versa. Combining these qualities with a language-centric design not only significantly simplifies traditional RPC systems, it adds functionality that was previously not possible. We designed Java Remote Method Invocation (RMI) to support pure-Java distributed objects in a seamless manner. RMI allows calls to be made between Java objects in different virtual machines, even on different physical machines     

反射中间件的研究

中间件处理的是复杂的分布式应用问题，因而常常面对变化的运行环境和不同的用户需求。当前的中间件，无论CORBA、DCOM还是JavaRMI基本上都采用了黑箱抽象的原则，缺少必要的灵活性和适应性。通过反射技术，可以使客户检索和调整系统的内部实现，以满足客户的特定服务质量要求。通过比较中间件的工作过程与反射计算，文章提出采用绑定具体化反射模型来设计中间件，并分析了这个反射模型的特点。文章还从绑定生成器、反射协议模栈，可配置的反射层等方面，介绍了一个反射中间件原型RECOM的实现。     

A configurable RMI mechanism for sharing distributed Java objects

Many distributed programming environments have been designed to support distributed shared objects over the Internet. Most of these environments (Java RMI and CORBA, for example), support client-server applications where distributed objects reside on servers, which execute all methods (remote or local) invoked on the objects. Traditional client-server models do not support client-side object caching and the local access it provides. We believe that object caching is critical to distributed applications, especially over the Internet, where latency and bandwidth are highly variable. We have developed a configurable and efficient remote method invocation mechanism that provides the same interface as Java RMI, while extending its functionality so that shared objects can be cached on the accessing nodes. The mechanism, called Javanaise, is based on the caching of clusters, which are groups of interdependent Java objects. We have implemented a prototype consisting of a preprocessor that generates the required proxy classes from the application interfaces and a run-time environment that uses system classes to manage the consistency of cluster replicas cached on client nodes. We describe the motivation for the work, the design choices made for the Javanaise clustering mechanism, the implementation principles for managing Javanaise clusters, and the results from three experiments that compare the performance of Javanaise with Java RMI     

基于分布对象技术的移动中间件

基于JavaRMI技术的移动中间件存在一定程度的局限性。文中以中间件、分布对象计算和移动计算等相关领域的技术为背景,提出了基于分布对象技术的移动中间件MMDO(MobileMiddlewareBasedonDistributedObject),该体系结构包括:动态可定制的基础核心、通用移动Agent平台、异步消息服务、动态资源发现和移动用户安全注册。MMDO能够解决移动中间件研究存在的Java效率问题,同时拓展了移动服务,给移动应用提供更好的支撑环境。最后,给出仿真测试结果,证明了MMDO的有效性。     

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.     

The impact of distributed programming abstractions on application energy consumption

With battery capacities remaining a key physical constraint for mobile devices, energy efficiency has become an important software design consideration. Distributed programming abstractions (e.g., sockets, RPC, messages, etc.) are an essential component of modern software, but their energy consumption characteristics are poorly understood. The programmer has few practical guidelines to choose the right abstraction for energy-constrained scenarios. In this article, we report on the findings of a systematic study we conducted to compare and contrast major distributed programming abstractions in terms of their energy consumption patterns. By varying the abstractions with the rest of the functionality fixed, we measure and analyze the impact of distributed programming abstractions on application energy consumption. Based on our findings, we present a set of practical guidelines for the programmer to select an abstraction that satisfies the energy consumption constraints in place. Our other guidelines can steer future efforts in creating energy efficient distributed programming abstractions.     

Context-aware RAON middleware for opportunistic network

Application development and deployment on Mobile Ad Hoc Networks (MANET) is a major challenge in the widespread use of MANET. The increasing D2D communication in 5G networks has renewed interest in an effective middleware design for MANET where application developers face various challenges such as unstable connectivity, high error rate, mobility induced disruption and disconnection, and limited battery power. We find that unstructured overlay network provides a good abstraction to facilitate application development and deployment on MANET. In this paper, we present the design of a middleware that builds a Resource-Aware Overlay Network (RAON), which is an unstructured overlay network of nodes engaged in the application that employs a query–reply mechanism for resource discovery. RAON is enhanced with features such as proactive neighbor replacement, congestion-aware data download and cooperative caching. Simulation results show that these features are effective in reducing query delay, improving data availability, and balancing node power consumption with protocol performance. We also present the middleware software design that offers the API based on node and path abstractions to applications. The middleware implements a generic context framework for acquiring device and user context. We discuss the implementation of application-level multicast and credit-based file-sharing applications using the middleware API. The middleware is implemented in Java J2ME on Android, which is tested in an ad hoc network of Nexus 7 devices running OLSR.     

支持QoS的IIOP的设计和实现

随着网络技术和中间件技术的发展,许多分布式应用（如多媒体,实时应用）要求支持多种QoS,如端到端的延迟、丢失率等。QoS与中间件平台的集成自然成了人们研究的焦点。当前流行的面向对象的中间件,如CORBA,DCOM和Java/RM1,在这一方面还不成熟。GIOP／IIOP是异种ORB在TCP／IP网络上互操作的基础,因而支持QoS的IIOP是支持QoS的CORBA的基础。本文首先简要介绍了IP的QoS模型和Windows2000中的QoS技术。在此基础上,详细讨论了支持了QoS的IIOP的设计和实现。     

Multi-technology distributed objects and their integration

Research on software objects, components, middleware, and component-based applications concerns among others ActiveX controls, JavaBeans (JBs), the Microsoft Transaction Server (MTS), Enterprise JavaBeans (EJBs), and how they can interoperate with each other. Is their interoperation possible? Which elements are responsible for the software objects' incompatibility? Is compatibility a responsibility of the objects or of their underlying architectures? In this article, we discuss object compatibility problems by outlining three basic middleware remoting technologies: the OMG's Common Object Request Broker Architecture (CORBA), Microsoft's Distributed Component Object Model (DCOM), and Sun's Java Remote Method Invocation (RMI), discussing the basic incompatibility points, and overviewing the basic strategies for bridging the gap between CORBA, DCOM, and RMI.     

实时性分布嵌入式系统设计

分布嵌入式系统的应用通常具有实时性要求，其实时性需要从任务调度、通信协议、调用接口和嵌入式操作系统四个方面得到支持。采用两阶段调度策略既可以保证调用的透明性，又可以简化任务调度算法；基于优先级的线路竞争算法可以改进以太网使其符合实时性要求；采用微型Java虚拟机作为分布式中间件可以为系统调用接口提供一个统一的支持平台。     

Real-Time Garbage Collection for a Multithreaded Java Microcontroller

We envision the upcoming of microcontrollers and systems-on-chip that are based on multithreaded processor kernels due to the fast context switching ability of hardware multithreading. Moreover we envision an extensive market for Java-based applications in embedded real-time systems. This paper introduces two new garbage collection algorithms that are dedicated to real-time garbage collection on a multithreaded Java microcontroller. Our garbage collector runs in a thread slot in parallel to real-time applications. We show that our algorithms require only about 5–10% of the processor time for an effective garbage collection concerning our real-time benchmarks.     

Comparative analysis of two different middleware approaches for reconfiguration of distributed real-time systems

Software-based reconfiguration of distributed real-time systems is a complex problem with many sides to it ranging from system-wide concerns down to the intrinsic non-robust nature of the specific middleware layer and the used programming techniques. In a completely open distributed system, mixing reconfiguration and real-time is not possible; the set of possible target states can be very large threatening the temporal predictability of the reconfiguration process. Over the last years, middle ware solutions have appeared mainly for general purpose systems where efficient state transitions are sought for, but real-time properties are not considered. One of the few contributions to run-time software reconfiguration in distributed real-time environments has been the iLAND middleware, where the germ of a solution with high potential has been conceived and delivered in practice.¹ The key idea has been the fact that a set of bounds and limitations to the structure of systems and to their open nature needs to be imposed in order to come up with practical solutions. In this paper, the authors present the different sides of the problem of software reconfiguration from two complementary middleware perspectives comparing two strategies built inside distribution middleware. We highlight the lessons learned in the iLAND project aimed at service-based reconfiguration and compare it to our experience in the development of distributed real-time Java reconfiguration based on distributed tasks rescheduling. Authors also provide a language view of both solutions. Lastly, empirical results are shown that validate these solutions and compare them on the basis of different programming language realizations.     

基于Java技术的Web环境下分布式数据库互操作性的实现

本文首先简要介绍了Ｊａｖａ技术和ＪＤＢＣ和ＲＭＩ机制的工作原理,讨论了如何应用ＪＤＢＣ实现在Ｗｅｂ环境下对异种数据库进行透明访问,如何采用ＲＭＩ机制消除Ｊａｖａ对Ａｐｐｌｅｔ程序的安全性限制,实现Ｗｅｂ环境下分布式数据库的互操作,最后给出了一个我们基于Ｊａｖａ技术设计和实现的Ｗｅｂ环境下Ｎ层Ｃｌｉｅｎｔ／Ｓｅｒｖｅｒ结构分布式数据库应用系统的模型。