Electrical computers and digital processing systems: multicomput – Computer-to-computer data routing – Least weight routing
Reexamination Certificate
1996-03-30
2001-07-10
Oberley, Alvin E. (Department: 2755)
Electrical computers and digital processing systems: multicomput
Computer-to-computer data routing
Least weight routing
Reexamination Certificate
active
06260074
ABSTRACT:
BACKGROUND OF THE INVENTION
FIELD OF THE INVENTION
The present invention relates to the fields of distributed computing systems, client-server computing and object oriented programming. Specifically, the present invention is a method and apparatus for providing program mechanisms which allow a generic or intermediate service to receive, hold and pass along a generic object without having the marshal and unmarshal code for the object of a specific type.
BACKGROUND
Typically, in object oriented systems, multiple processes are executing in multiple address spaces, and the processes are invoking the methods on objects in the same address space or in a different address space. With respect to local objects (i.e., serverless objects), invoking methods on these local objects are relatively straightforward since the implementation code associated with the methods reside in the same address space. When invoking methods of objects that are remote (i.e., across address spaces that may cross machine boundaries), a remote procedure call is typically employed to invoke the methods of remote objects.
When invoking the methods of objects across address spaces, arguments or parameters are typically passed or communicated. For example, simple variables such as int, char, string, and complex variables, such as arrays and records, may be passed between address spaces. In object oriented systems, objects such as serverless objects or remote (server-based) objects may also be passed from one address space to another.
FIG. 1
illustrates a serverless or local object
2
. The serverless object
2
is located in a single address space and includes methods
4
and corresponding implementation code
6
for the methods. The serverless object
2
also includes state or data
7
. When a serverless object
2
is passed as an argument across address spaces, its entire state or data
7
is passed (i.e., the entire state or data
7
is marshaled and unmarshaled).
Marshaling is simply an operation that is used when transmitting an object between address spaces. Marshaling takes the current object and places enough information (i.e., the marshaled form of the object) in a communications buffer so that an essentially identical object can be unmarshaled from this buffer in another address space. Unmarshaling is simply an operation that is used when receiving an object from another address space. Unmarshaling creates or fabricates an object in the new address space by using the marshaled form (e.g., a string of bits) of the transmitted object.
An intermediate service or generic service that receives, holds and passes along a serverless object is required to have the marshal and unmarshal code for the type of the serverless object.
FIG. 2
illustrates a remote (server-based) object
8
. This remote object
8
includes methods
10
that interface with stubs
12
. The remote object
8
includes the client side representation
14
of the state. This client side representation
14
is typically a remote pointer to the implementation code
20
(e.g., network pointers to the actual location of the code). The client side representation
14
of the state points to the state or data
18
that is disposed in a server
16
, which is remote from the client where the server-based object
8
resides. Stubs
12
are code that request execution of corresponding implementation code on server
16
associated with the particular method
10
of interest.
When a remote object is passed as an argument, its client side representation of state
14
is passed (i.e., the client side representation is marshaled and unmarshaled). In some object oriented systems, the representation for a remote (server-based) object is fixed. In these systems, the marshal and unmarshal code of these remote objects are distributed to the services in a network. In more flexible object oriented systems, the client side representation of a remote object is variable and not static. In these systems, code (subcontract) is necessary to handle the different object representations. For further information on subcontracts see “Subcontract: A Flexible Base for Distributed Programming” from “A Spring Collection, A Collection of Papers on the Spring Distributed Object-Oriented Operating System”, September 1994. Accordingly, for remote objects having variable representations, an intermediate or generic service needs the code for a subcontract that handles the particular type of the remote object.
OBJECTS OF GENERIC TYPES
Many systems have generic types. Examples are type “Any” and type “Object” in CORBA compliant systems. For further information on CORBA, see the “Common Object Request Broker: Architecture and Specification”, Revision 2.0, July 1995. Another example is the type “named” in the Spring Operating System developed by Sun Microsystems. For further information on Spring, see “A Spring Collection, A Collection of Papers on the Spring Distributed Object-Oriented Operating System”, September 1994. Variables of specific types can be converted to variables of one of these generic types. The term, “Variables”, as used herein includes objects. Objects are special kinds of variables that are defined by specifying an interface and allow subclassing by inheritance. For example, in CORBA a variable (e.g., an object) of any type can be converted to a variable of type “Any”. In CORBA compliant systems and systems using the Java language an object of any type can be converted to a variable of type “Object”. In Spring any variable (e.g., object) can be converted to a variable of type “Named.”
FIG. 3
illustrates the mechanism of marshaling and unmarshaling when passing an object of a specific type (T)
22
from a first address space
24
to a second address space
26
(e.g., across machines in a network). The object
22
of a specific type T is passed from a first address space
24
to a second address space
26
in accordance with the following steps. First, a marshal procedure marshals the state or data
23
of the object
22
to generate a marshaled form of the state of object. The marshaled form of the state of the object is placed into a marshal buffer
30
. A copy of the marshal buffer
30
is transmitted from the first address space
24
to the second address space
26
. A marshal buffer
32
corresponding to the second address space
26
receives the marshaled form of object of Type T. An unmarshal procedure unmarshals the marshaled form of the state of the object and creates the object
34
in its unmarshaled state. As noted previously, the passing of an object of a specific type occurs as part of invoking a method of an object where an object of a specific type T is passed as an argument.
When an object of a specific type T is passed between address spaces, the object is marshaled on the transmit side and unmarshaled on the receiving side. The marshaled form of the object of type T is usually specific to type T. A sender needs to have marshal code to perform the marshaling of the object of type T. A receiver needs to have unmarshal code to perform the unmarshaling of the object of type T. An intermediate service (generic service) needs to have both the marshal code and the unmarshal code to perform the marshaling and unmarshaling of the object of type T since a generic service receives a generic object, holds it, and communicates it to another address space.
FIG. 4
illustrates a prior art technique of passing generic objects from a first address space
40
to a second address space
41
and then to a third address space
42
. Again, the passing of generic objects arises as part of invocation of a method, when a generic object is passed as an argument in the method. First, an object
44
of type T (where T may be any type) is converted or widened
38
into a generic object
45
. Next, a marshal procedure marshals
39
the generic object
45
(i.e., marshals the type identification and state of the generic object). Marshaling the state/data of the generic object entails marshaling the object of type T
43
. This marshal procedure generates a marshaled form of the generi
Kessler Peter
Radia Sanjay R.
Blakely & Sokoloff, Taylor & Zafman
Oberley Alvin E.
Stecher Peter
Sun Microsystems Inc.
LandOfFree
Method and apparatus for passing generic objects in a... does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Method and apparatus for passing generic objects in a..., we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Method and apparatus for passing generic objects in a... will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-2460252