Search

CORBA is becoming one of the most important middleware for supporting object-oriented and client/server paradigms in distributed computing systems. However, application systems based on CORBA are still scarce to date. One reason is that only few CORBA object services have been developed. To have a new CORBA application, a programmer must make the effort to design a program with a CORBA interface. In our previous work [Proceedings of the Sixth IEEE Computer Society Workshop on Future Trends of Distributed Computing Systems (1997) 2], a re-engineering approach was proposed to convert RPC-based programs into CORBA objects. This has successfully increased the development of CORBA applications. However, the source code is required in this approach. In many cases, software designers cannot acquire the source code. This prevents adapting existing PC software applications, particularly for Windows applications. Our study addresses this problem. A graphic factory temperature monitor system, which integrates MS-Excel under MS-Windows, was implemented to demonstrate the feasibility of our approach.

The distributed and heterogeneous natures of todays computing systems require a middleware Infrastructure capable of supporting a three-tier computing architecture. Business logic can be built, or existing applications encapsulated, Into middle tier components that Interact with end users via standard Interfaces such as web browsers and standard GUI desktops, and back-end data repositories. The Common Object Request Broker Architecture, or CORBA for short, is a specification produced by the Object Management Group (OMG) that addresses Interoperability in distributed heterogeneous environments. The CORBA standard represents industry consensus from more than 800 companies. It is an open, vendor-independent architecture and Infrastructure that computer applications use to work together over networks. Using the standard protocol IIOP, a CORBA-based program from any vendor, on almost any computer, operating system, programming language, and network, can interoperate with a CORBA-based program from the same or another vendor, on almost any other computer, operating system, programing language, and network. It defines an Object Request Broker (ORB) for transparent invocation of remote objects, as well as supporting system level Object Services and higher level Common Facilities. CORBA assumes a heterogeneous environment In which objects Implemented in different languages on different platforms can inter-operate. There are many implementations of the CORBA standard, some of them in the form of commercial products that have demonstrated strong market acceptance. This paper presents CORBA In a simple and easy to understand language. It assumes only a basic familiarity with computers and programming languages. Object Services is one of the five integral components of the Object Management Architecture (OMA) - which forms the heart of CORBA. There are several Object Services like Collection Service, Concurrency Service, Event Service, Naminty Service, Query Service, Notification Service, Time Service, Transaction Service, etc. This paper presents in a very simplified form, one of these services called as CORBA notification Service. It compares and contrasts It with the Event Service and discusses the deficiencies In Event Service and how the Notification Service resolves them. The applicability of the Notification Service in real-life scenarios Is also discussed.

CORBA (Common Object Request Broker Architecture) provides 16 Common Object Services for distributed application development, but none of them are fault-tolerance related services. In this paper, we propose a replicated object based Fault-Tolerant Object Service (FTOS) for CORBA environment. Two fault-tolerant mechanisms are provided in FTOS including dynamic voting mechanism and object replication mechanism. The dynamic voting mechanism uses majority-voting strategy to ensure object state consistency in failure situations. The object replication mechanism can help system administrators to replicate and start-up objects easily. Our implementation provides a library according to the style of COSS. With this library, programmers can develop distributed applications with fault-tolerance capability very easily.

The authors describe a distributed programming model based on an object group service (OGS) and discuss various levels of group transparency and their impact on invocation overheads. Their OGS extends CORBA so that it can gather several objects inside a group and transparently handle group membership and consistent invocation of group members.

Many computer applications today require some form of distributed computing to allow different software components to communicate. Several different commercial products now exist based on the Common Object Request Broker Architecture (CORBA) of the Object Management Group. The use of such tools, however, often requires the modification of existing systems, rather than the development of new applications. The objective of this research has been to integrate the use of a CORBA tool into an existing engineering design application for the purpose of (1) evaluating the amount of re-engineering that is involved to effectively integrate distributed object computing into an existing application, and (2) evaluating the use and performance of distributed object computing in an engineering domain, which often requires the transfer of large amounts of information. The results of this work demonstrate that CORBA technology can be easily integrated into existing applications. The ease of the integration as well as the efficiency of the resulting system, however, depends upon the degree of modification that developers are willing to consider in the re-engineering process. The most transparent approach to the use of CORBA requires less modification and generally produces less efficient performance. The less transparent approach to the use of CORBA can potentially require significant system modification but produce greater performance gains. This work outlines issues that must be considered for the partitioning of functionality between the client and the server, development of an IDL interface, development of client and server-side wrappers, and support for concurrent, multi-user access. In addition, this work also provides performance and implementation comparisons of different techniques for the use of wrappers and for the transfer of large data files between the client and the server. Performance comparisons for the incorporation of concurrent access are also presented. Copyright © 1999 John Wiley & Sons, Ltd.

The integration of distributed computing and the object model leads to distributed object computing, in which objects rather than processes are distributed across multiple computers. A well-established standard for distributed object computing is the Common Object Request Broker Architecture (CORBA). Previously, you would have had to create-and enable the application to use-the components that provide such additional capabilities. Using these components requires specialized knowledge and understanding of problems outside the application domain. With the advent of interceptors-non-application components that can alter application behavior-you can enhance CORBA applications at runtime with components whose operation is transparent to both the application and the CORBA framework, modifying application behavior without modifying the application or the CORBA framework.

Distributed real-time applications have presented the need to extend the Object Management Group‘s Common Object Request Broker Architecture (CORBA) standard to support real-time. This paper describes a Dynamic Real-Time CORBA system, which supports the expression and enforcement of end-to-end timing constraints as an extension to a commercial CORBA system. The paper also describes performance tests that demonstrate the system‘s ability to enforce expressed timing constraints.

The World Wide Web and Distributed Object-Oriented Systems (e.g. CORBA) provide future infrastructures for distributed client/server computing. This paper presents our work to provide the integration of CORBA objects into the Web: first, to describe Web services using object-oriented technologies and second to access any Information System developed with CORBA from the Web. We present a new Shared Information Space model with the following issues: Object Orientation Design, Distributed and Heterogeneous Environment, Users' Point of View, Object Invocation and Navigation. Navigation over SIS is supported by CorbaWeb, a Generic Object Navigator, composed of metascripts allowing the access, the representation and the invocation of any CORBA object from the Web. These operations are achieved by scripts written in CorbaScript, an interpreted scripting language which can dynamically invoke any CORBA objects.

Existing object databases allow the behaviour of an object to be defined in terms of methods declared by types. Such methods provide modular access to data fields and other computational functionality. Usually, the type of an object is fixed and therefore changes to its behaviour involves schema evolution. Consequently, dynamic configurations of object behaviour are generally not supported. We define the notion of role-based object behaviour and show how we integrated it into an existing object database extended with a notion of collections to support object classification and role modelling. We present a metamodel that enables specific services to be associated with objects based on collection membership and show how such a model supports flexible runtime configuration of loosely coupled services. We further outline how this role-driven service invocation mechanism might be applied in different application scenarios.

The Common Object Request Broker Architecture (CORBA) from the Object Management Group has been the most influential standard in the OO world and one of the principal steps in the industry's move to component-based development. The author gives us a preview of CORBA 3, the next step in the technology.

Typically, objects are monolithic entities with a fixed interface. To increase the flexibility in this area, this paper presents first-class object sets as a language construct. An object set offers an interface which is a disjoint union of the interfaces of its member objects. It may also be used for a special kind of method invocation involving multipleobjects in a dynamic lookup process. With support for feature access and late-bound method calls object sets are similar to ordinary objects, only more flexible. The approach is made precise by means of a small calculus, and the soundness of its type system is shown by a mechanically checked proof in Coq.

The problems of finding objects in large and wide-area networks where objects may change their location in volatile memory as well as on stable storage are presented. The authors discuss possible solutions and describe those adopted in the Hermes system (a corporate wide, real life office application). They have designed and developed a location-independent-invocation (LII) mechanism that combines finding with invocation, using temporal location information. The mechanism also updates the system's knowledge of an object's location as a side-effect of invocation and object migration. Assumptions about object mobility indicate that objects are likely to be found within a few propagations of an invocation. If they cannot be found in this way, stable-storage and name services are used to locate the object. The major contribution of this work is to show how LII can be achieved in a large and dynamic environment in which objects are supported by neither are operating system nor the programming language. >

Object mobility is the basis for highly dynamic distributed applications. This paper presents the design and implementation of mobile objects on the basis of the CORBA standard. Our system is compatible to the CORBA Life-Cycle–Service specification and thus provides object migration between different language environments and computer systems. Unlike others, our Life-Cycle–Service implementation does not need vendor-specific extensions and just relies on standard CORBA features like servant managers and value types. Our implementation is portable; objects can migrate even between different ORBs. It supports object developers with a simple programming model that defines the state of an object as value type, provides coordination of concurrent threads in case of migration, and takes care of location-independent object addressing. Additionally we seamlessly integrated our implementation with a dynamic code-loading service.

This paper describes a technique that allows an MPI code to be encapsulated into a component. Our technique is based on an extension to the Common Object Request Broker Architecture (CORBA) from the OMG (Object Management Group). The proposed extensions do not modify the CORBA core infrastructure (the Object Request Broker) so that it can fully co-exist with existing CORBA applications. An MPI code is seen as a new kind of CORBA object that hides most of the cumbersome problems when dealing with parallelism. Such technique can be used to connect MPI codes to existing CORBA software infrastructures which are now being developed in the framework of several research and development projects such as JACO3, JULIUS or TENT from DLR. To illustrate the concept of parallel CORBA object, we present a virtual reality application that is made of the coupling of a light simulation application (radiosity) and a visualisation tool using VRML and Java.

The paper presents a proposal for incorporating a group communication paradigm into an object-based environment. Group communication is an interaction involving an arbitrary number of participants. Its application simplifies specification and implementation of complex systems. Object-oriented programming can significantly profit from the addition of a group mechanisms. The proposed mechanism, Multiple Object Invocation, provides group communication among objects. The paper first presents a model of general structure of group services and the use of group communication in this model. Multiple Object Invocation is presented and its characteristics and application in the general model is discussed. Implementation of Multiple Object Invocation in the Emerald object-oriented language and distributed operating system is presented. >

This paper presents COMET, a Common Object Management Environment, that investigates basic problems associated with distributed computing in an internet environment with mobile objects. COMET offers a uniform invocation model, based on dialogues, that integrates both communication and execution aspects. On the communication side, dialogues support asynchronous invocation with preservation of causal relationships. Applications can thus take advantage of the increased parallelism that is possible in a distributed environment. Furthermore COMET's invocation model supports multiple object flavors, offering high-level functionality, s.a. persistence, replication and atomicity. This is realized by modeling invocations as flavor-specific actions, that manipulate typed memory. Reflective techniques are used to dynamically adjust dialogue algorithms according to object flavor. >

Invocation batching combines multiple object invocations into a single message; result chaining makes results from one batched invocation available to the other invocations batched with it. Invocation chaining, or the combination of invocation batching with result chaining, is the key to allowing lightweight objects to be manipulated efficiently across heavyweight boundaries, whether between machines, between address spaces, or between user and kernel. By reducing the number of boundary crossings, invocation chaining reduces the total cost of invocation, making it more effective than previous solutions such as asynchronous messaging. This paper describes an initial implementation of invocation chaining. >

CORBA is becoming the most important middleware that supports the object-oriented and client/server paradigm in distributed computing systems. However, the application systems based on CORBA are still scarce. One main reason is that only a few CORBA object services have been developed. To develop a new CORBA application, a programmer should make an effort to design a program with a CORBA interface from scratch. In our previous work (Liang et al., 1997), a re-engineering approach was proposed to convert RPC-based programs to CORBA objects, which successfully speeds up the development of CORBA applications. However, the source code is required in this approach. In many cases, software designers may not get hold of the source code. It will be significant to adapt existing PC application software in binary code mode to the object services under CORBA. Our study is addressing this problem. A graphical parking lot management system, which integrates dBase III and AutoCAD V2.6i under DOS has been implemented to demonstrate the feasibility of our approach.

Most bindings to CORBA are based on the construction of stubs, which translate a language call into a CORBA invocation. The paper shows an alternative way to build a binding, using the reflexive facilities of an interpreted language. Like other CORBA bindings, this binding allows a program to manipulate CORBA objects in the same way it manipulates local objects. Unlike conventional bindings however, it is based on the CORBA Dynamic Invocation Interface, mapping its dynamic character to the dynamic type system of the language. In this way, a program has immediate access to any CORBA component, without the need of stubs or pre-defined IDL headers.

The reliable object invocation mechanism provided by HIDRA for the coordinator-cohort and the passive replication models offers support to ensure that all the replicas of the object being invoked are correctly updated before such an invocation is terminated. This mechanism also ensures that if a primary or coordinator replica crashes, the client is able to reconnect to the previously initiated invocations, collecting their results without requiring their reexecution. All this support is provided transparently to the client of the replicated objects, which does not notice any difference in respect to the invocations made to non-replicated objects. Moreover, the protocols described in the paper deal also with the failure of any of the objects involved in this kind of invocations.

Designing system software for large scale shared memory multiprocessors is challenging because of the level of performance demanded by the application workload and the distributed nature of the system. Adopting an object oriented approach for our system, we have developed a framework for de clustering objects, where each object may migrate, replicate, and distribute all or part of its data across the system memory using the policies that will best meet the locality requirements for that data. The mechanism for object invocation hides the internal structure of an object, allowing a request to be made directly to the most suitable part of the object on a per processor basis without any knowledge of how the object is de clustered. Method invocation is very efficient, both within and across address spaces, involving no remote memory accesses in the common case. We describe the design and implementation of this framework in Tornado, our multiprocessor operating system. >

This paper addresses efficient object invocation in distributed systems. Such systems include support for transparent object migration between computers connected by a network, delegation and revocation of access to objects in a system, and very high speed communication between objects, whether they are located in the same machine or across the network from each other. Asynchronous Transfer Mode (ATM) networks can be effectively utilized to implement many of the necessary features of secure, location transparent object invocation. By using the switch controller in an ATM network as a repository for location information, and by mapping virtual circuits to pairwise object interactions with explicitly declared rights of each object, we are able to provide a high performance system that is both secure and simple. >

CORBA is becoming the most important middle-ware that supports object-oriented and client/server paradigm in distributed computing systems. However the CORBA-based application systems are still scarce up to date. One main reason is that only few CORBA object services have been developed. To have a new CORBA application, a programmer should make efforts to design a program with CORBA interface from scratch. In our previous works, we successfully adapted existing PC software applications, particularly for Windows applications, in binary code mode to the object services under CORBA. To facilitate such reuse, a design pattern supporting design process guidelines is desired. Our study is addressing this pattern with pattern language. A graphic factory temperature monitor system, which integrates MS-Excel under MS-Windows has been implemented to demonstrate the feasibility of our approach.

Many-to-Many Invocation (M2MI) is a new paradigm for building collaborative systems that run in wireless proximal ad hoc networks M2MI provides an object oriented method call abstraction based on broadcasting. An M2MI invocation means "Every object out there that implements this interface, call this method." An M2MI-based application is built by defining one or more interfaces, creating objects that implement those interfaces in all the participating devices, and broadcasting method invocations to all the objects on all the devices.

This tutorial provides the basics that developers need to begin understanding the Common Object Request Broker Architecture (CORBA) and using it to write industrial-strength distributed systems. You will learn about the basics of the Object Management Group's (OMG) Object Management Architecture (OMA), with a focus on its CORBA component. By the end of the tutorial, you will understand how to write object interface specifications using the OMG Interface Definition Language (IDL), how to write simple distributed applications in C++, how to use the Portable Object Adapter (POA), the Dynamic Invocation Interface (DII) and the Dynamic Skeleton Interface (DSI), and the Interface Repository (IFR). You will also know the basics of several CORBA services such as Naming, Trading, and Events.

The field of distributed parallel programming is predominated by tools such as the Parallel Virtual Machine (PVM) and the Message Passing Interface (MPI). On the other hand, mainly standards like the Common Object Request Broker Architecture (CORBA), Remote Method Invocation (RMI), and the Distributed Component Object Model (DCOM) are used for distributed computing. In this paper, we examine the suitability of CORBA-based solutions for meeting application requirements in the field of parallel programming. We outline concepts defined within CORBA which are helpful for the development of parallel applications. Subsequently, we present our design of an object group service and a join service which facilitate the development of CORBA-based distributed and parallel software applications by transparently encapsulating typical forking and joining mechanisms often needed in that context.

The paper provides an overview of the basic concepts of OMG CORBA. It summarizes the main ideas behind the OMG Reference Model Architecture and the components it defines. Particular attention is paid to the Object Request Broker and Object Services. An evolving example is used to illustrate the CORBA philosophy. The authors draw on their long-term practical experience with CORBA, particularly with implementing the Persistent Object Service [KPT96].

The object invocation paradigm is attractive for structuring distributed systems. Distributed object-based operating systems view the resources of the system as a collection of objects. Object invocation is the primary mechanism in such systems, and is often used as a yardstick for measuring the system performance. However, existing systems of this flavour exhibit poor performance due to the mismatch between the requirements of the object invocation mechanism and the machine architecture. Through measurements of an existing object-based kernel, we present a breakdown of the costs involved in implementing the object invocation mechanism. The measurements suggest architectural solutions to improve the performance of such systems. We present our preliminary studies towards providing hardware support for the object invocation mechanism.

The Common Object Request Broker Architecture (CORBA) is becoming a standard for distributed application middleware, but no support is currently provided to handle object replication. In this paper, we discuss the relevance of using the Object Management Group's Event Service for replicating objects in a CORBA environment and compare it to other approaches.

Distributed system frameworks (also known as middlewares) are developed to wrap distributed components regardless of their program languages, operating systems, and hardware platforms. Middleware hides networking details from application developers, and it increases reusability and reconfigurability of developed systems. CORBA (Common Object Request Broker Architecture) is a standard middleware. We adapt CORBA for our multi-robot research since it hides all network program details from programmers. Thus, CORBA increases development efficiency and component reusability. Recently Real-time CORBA (RT-CORBA) has been defined by Object Management Group (OMG), and it supports many real-time properties. Using RT-CORBA, we can define and implement real-time applications with stringent end-to-end quality of service (QoS) requirements. In this research, we tested one of the RT-CORBA properties. We show our testing result of a propagated priority model to guarantee that a high priority client invocation can be processed before that of a low priority client.

The Emerald compiler analyzes object definitions and attempts to produce efficient implementations commensurate with the way in which objects are used. For example, an object that moves around the network will require a very general remote procedure call implementation; however, an object that is completely internal to that mobile object can be implemented using direct memory addressing and inline code or procedure calls. We wanted to achieve performance competitive with standard procedural languages in the local case and standard remote procedure call systems in the remote case. These goals are not trivial in a location-independent object-based environment. To meet them, we relied heavily on an appropriate choice of language semantics, a tight coupling between the compiler and run-time kernel, and careful attention to implementation. As an example of Emerald's local performance, Table 1 shows execution times for several local Emerald operations executed on a Micro VAX II 1 . The “resident global invocation” time is for a global object (i.e., one that can move around the network) when invoked by another object resident on the same node. By comparison, other object-based distributed systems are typically over 100 times slower for local invocations of their most general objects [6, 1]. The Emerald language uses call-by-object-reference parameter passing semantics for all invocations, local or remote. While call-by-object-reference is the natural semantics for object-based systems, it presents a potential performance problem in a distributed environment. When a remotely invoked object attempts to access its arguments, those accesses will typically require remote invocations. Because Emerald objects are mobile, it may be possible to avoid some of these remote references by moving argument objects to the site of a remote invocation. From this table we can compute the benefit of call-by-move for a simple argument object. For this simple argument object, the additional cost of call-by-move was 2 milliseconds while call-by-visit cost 6.4 milliseconds. These are computed by subtracting the time for a remote invocation with an argument reference that is local to the destination. The call-by-visit time includes sending the invocation message and the argument object, performing the remote invocation (which then invokes its argument), and returning the argument object with the reply. Had the argument been a reference to a remote object (i.e., had the object not been moved), the incremental cost would have been 30.8 milliseconds. These measurements are somewhat of a lower bound because the cost of moving an object depends on the complexity of the object and the types of objects it names. Emerald currently executes on a small network of MicroVAX IIs and has recently been ported to the SUN 3 2 . We have concentrated on implementing fine-grained mobility in Emerald while minimizing its impact on local performance. This has presented significant problems; however, through the use of language support and a tightly-coupled compiler and kernel, we believe that our design has been successful in meeting both its conceptual and performance goals.