AU747472B2 - Method for creating a distributed object tree - Google Patents
Method for creating a distributed object tree Download PDFInfo
- Publication number
- AU747472B2 AU747472B2 AU36629/00A AU3662900A AU747472B2 AU 747472 B2 AU747472 B2 AU 747472B2 AU 36629/00 A AU36629/00 A AU 36629/00A AU 3662900 A AU3662900 A AU 3662900A AU 747472 B2 AU747472 B2 AU 747472B2
- Authority
- AU
- Australia
- Prior art keywords
- request
- central directory
- son
- father
- logical name
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Ceased
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/28—Databases characterised by their database models, e.g. relational or object models
- G06F16/289—Object oriented databases
Landscapes
- Engineering & Computer Science (AREA)
- Databases & Information Systems (AREA)
- Theoretical Computer Science (AREA)
- Data Mining & Analysis (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
- Multi Processors (AREA)
- Small-Scale Networks (AREA)
- Computer And Data Communications (AREA)
Description
WO 00/60452 PCT/FROO/00802 METHOD OF IMPLEMENTING A TREE OF DISTRIBUTED OBJECTS The present invention concerns a method of organizing distributed objects in a hierarchy.
The invention applies to many applications employing a distributed object environment, for example telecommunication or transportation supervision applications, applications constituting an intelligent network, etc.
In a distributed object environment, an application can use different servers to provide services to clients.
The term "process" refers to a program which runs in a given environment.
SAn object of the process is a software entity in the process.
In an application, the distributed objects are in practice organized in accordance with a given tree.
In the tree, each object has a logical name, i.e. a character string, which specifies the logical access path to that object from the starting object, i.e. the root, of the tree. The logical name is absolute in the sense that it is determined relative to the root.
It is also possible to specify the logical access path from an object other than the root. The term "relative logical name" is then used.
In any distributed object system based on an ORB, it is often necessary to access objects directly. The absolute or relative logical names of the objects must be used for this, enabling a logical access path to the required object to be found.
Furthermore, it is generally possible to ask a father object directly for access S 25 to a son object. In the request to the father object the relative logical name relative to the father object is used to designate the son object.
Because the objects are distributed, the tree of the objects in practice has many branches and the branches or parts of the branches can correspond to distinct processes. Figure 1 is a diagram showing a simplified example of an object tree.
Under a main process P0, which constitutes the root of the tree of the system, there are three distinct processes P1, P2, P3. The process P1 situated directly under the root comprises three objects, namely a first object A, which is the entry object or root of the process, from which depart two branches to two objects B and C.
A final branch departs from the object B towards an object D of the process P2.
The process P3 situated directly under the root comprises a single object X.
WO 00/60452 PCT/FROO/00802 In a practical implementation of the tree of the system the objects contain information on their respective sons. If the son objects are contained in the same process as the father object, the information consists of pointers giving the physical addresses of the son objects. If the son objects are not contained in the same process as the father object, the information is made up of references. For example, the object A contains a pointer to the object B and a pointer to the object D. The object B contains a reference to the object D.
The logical access path for accessing the object D from the root, i.e. the absolute logical name, can be written It is therefore necessary to pass through the object B to arrive at the object D. This is the case whether the object D is reached by interrogating the object B directly, that object being identified by the absolute logical name for the son object identified in the object B by a reference, or by interrogating the root for the object identified by the (absolute) logical name /A/B/D.
The objects A and B are in the process P1 and the object D is in another process P2. If the process P1 is not running, or has failed, it is no longer possible to access the object D with this tree.
Furthermore, this tree makes managing process redundancy difficult. In the example shown in figure 1, there is a redundant back-up process P2' which is substituted for the process P2 if it fails. With the tree previously explained, it is up to each object that receives a request regarding an object that is not in its process to determine to which of the two processes P2 and P2' it should transmit the-request.
Clearly this makes managing redundancy particularly complex. Redundant processes are routinely used to strengthen the weak points of a system, i.e. the processes that O 25 are likely to fail often, whether their failure paralyses the entire system or merely reducesthe quality of service.
For the above reasons a different tree of the objects of a distributed object system has been proposed, to enable access to all the objects of the system even if some father objects are not available (failed or stopped) and to simplify the management of process redundancy. This tree employs centralized management of the tree at the level of the root, by means of a central directory, which contains structured names of all the objects. In other words, it contains all of the tree of the system.
In this tree, if a father object is interrogated for a son object, the call is redirected to the central directory. It is then always possible to access an object even WO 00/60452 PCT/FROO/00802 if, within the tree, that object is a son of other processes which are stopped. What is more, this also centralizes management of redundancy, which is managed by means of the same central directory.
However, this tree is very costly in terms of resources: if the number of objects is large, the central directory can be overloaded and the performance of the system seriously degraded, because of the time needed to consult the tree in the central directory for each call.
Furthermore, this solution no longer takes into account the specific nature of the distributed environment, since it treats each object identically. All calls are processed by the central directory, even if the call concerns a son object of a father object in the same process. This increases the volume of inter-process communication unnecessarily.
Finally, if the system uses the object-object protocol based on the creation of pairs of representative elements, for example the proxy/stub pairs of distributed environments based on the DCOM ORB, as the protocol for communication between objects, the centralized directory solution multiplies the number of these pairs, because it implies the creation of a pair of representative elements for each object in the tree. The pairs of representative elements are very costly in terms of memory resources.
Accordingly, an object of the invention is to provide a method of implementing a tree of distributed objects that does not have the aforementioned disadvantages.
The invention uses a central directory which contains tree information on only certain targeted objects, and so all the objects of a process can be accessed.
According to the invention, if a father object receives a location request in respect of a son object, it accesses the son object, if the latter is in the same process, or returns the call to the central directory, if it is not in the same process.
In other words, the tree within a given process is managed internally in that process, the objects of the process containing the necessary pointers to the son objects contained in the process, i.e. the physical addresses of those objects in the process concerned, but the tree of processes is managed by the central directory.
This has the advantage of providing access to objects of son processes even if a father process is stopped; this enables problems of redundancy at the level of the central directory to be managed; finally, it enables the response time of the central directory to be optimized, because it has only a partial tree to manage, and it WO 00/60452 PCT/FRO0/00802 enables the memory resources necessary for implementing the tree to be optimized.
As characterized, the invention therefore concerns a method which includes a step consisting of assigning to a father object in a process, for each son object: information corresponding to a physical address pB if the son object is contained in same process, or information referring back to said central directory if the son object is not contained in the same process.
Other features and advantages of the invention are described in the following description, which is given by way of non-limiting illustrative example only, and with reference to the accompanying drawings, in which: figure 1, already described, is a simplified block diagram of a prior art tree of distributed objects; and figure 2 is a block diagram of a tree of distributed objects in accordance with the invention.
The invention provides o central directory corresponding to the process PrO in figure 2. That process is the root of the tree.
There are different processes under the root process PrO.
A first process Prl contains three objects A, B and C. In this process, the object A is the root object. The root object of a process is an entry object of the process. Note that there can be more than one in the same process.
The objects B and C are two son objects of the object A.
A redundant process Prl' is a replica of the first process. In particular, it contains the same objects with the same tree.
A second process Pr2 contains two objects D and F. In this process, the object D is the root and the object F is a son object of the object D. The object D is also a son object of the object B of the process Prl.
A redundant process Pr2' is a replica of the second process. In particular, it contains the same objects with the same tree.
The central directory contains a data structure TabO in which it stores information relating to the tree of the system.
In practice, it contains at least all the information relating to the entry objects (root objects) of each distinct process of the tree.
In this example, in entry El of the data structure there is information relating to the object A of the process Prl: logical name relative to the central directory /A, pointer pPrl to the corresponding process Prl, and other information required for its WO 00/60452 5 PCT/FROO/00802 management.
In entry E2 there is information concerning the object A of the redundant process Prl'; in entry E3 there is information on the object D of the process Pr2; in entry E4 there is information on the object D of the process Pr2'.
The central directory therefore contains the tree of the processes in the system.
According to the invention, a father object in a process (other than the central directory), contains information on its son objects, which takes the form of pointers, i.e. their physical addresses, if they are contained in the same process. Thus the object A contains pointers pB and pC to the son objects B and C, respectively.
If the son object is not in the same process, the father object contains information for returning the call to the central directory. Thus if the object B receives a request for the son object D identified by its logical name /D relative to the object B, the object B returns the request to the central directory.
In practice, it returns the request by placing the character string of its own absolute logical name, relative to the central directory, in front of the character string of the relative logical name of the object D. In the example, the absolute logical name of the object B is the character string Accordingly, the object B transmits the request to the central directory by supplying it with the absolute logical name of the object D.
If the central directory receives a request relating to an object identified by its logical name relative to the central directory, it consults its internal data structure, which is of the dictionary type, and looks up the corresponding character string. If it finds it, it obtains a corresponding reference of the object in the system. That reference enables it to transmit the request directly to the object. If it does not find it, it looks for the longest character string corresponding to a first part of the character string, in order to transmit the request to a father object for the given object identified by its relative name relative to that father object. That relative name is obtained as the reference between the two character strings. Take the example of a request received by the directory for the object C defined by its logical name The central directory searches its data structure for that string or the longest string corresponding to its first part the start of the string). In this example it will find the string which is the logical name of the object A.
It therefore transmits the request relating to the object C to the object A, sending it by way of identification the relative logical name of the object C relative to WO 00/60452 PCT/FROO/00802 the object A. That relative logical name is simply obtained as the difference between the two character strings: /A/C /A /C.
In accordance with the invention, if the object to which the directory has sent a request relating to a son object cannot find the son object in its process, it sends a message to the central directory, which looks for another object in its directory. It can also place corresponding information in its data structure.
With regard to managing redundancy, figure 2 shows that the data structure TabO contains all the objects with the same logical names corresponding to different processes. To each entry in the table there corresponds a physical identification of the corresponding process. Thus in entry El there is the name /A for a process identified by a parameter pPrl corresponding to the process Prl. In the entry E2 there is the name /A for a process identified by a parameter pPrl' corresponding to the redundant process Prl'.
As in the invention, as soon as an object of a process has a request relating to a son object of another process to manage, it sends its request to the central directory, which is entirely responsible for managing redundancy. In other words, it is the central directory which determines at a given time whether to send the call to the process Prl or to its process Prl', depending on information on the status of the system. Thus management of redundancy is centralized.
As already mentioned, the central directory preferably contains information relating to the entry objects (root objects) of each process of the system. It therefore contains the tree of the processes (including the redundancy), while the tree in the processes is implemented internally in each process.
Finally, note that the central directory is a sensitive point of the system. Thus in practice protection mechanisms or a redundant central directory are provided in order to obtain a robust mechanism.
It has been shown that the invention applies in a distributed object environment.
One particular application concerns an environment based on a distributed Object Request Broker (ORB). ORBs known in the art include the CORBA (Common Object Request Broker Architecture) and DCOM (Distributed Component Object Mode) ORBs.
Claims (9)
1. A method of implementing a tree of distributed objects in different processes, there being a central directory (PrO) adapted to store information on objects in a data structure (TabO) at the root of the tree, characterized in that it includes a step consisting of assigning to a father object in a process, for each son object information corresponding to a physical address (pB) if the son object is contained in same process, or information referring back to said central directory if the son object is not contained in the same process.
2. A method according to claim 1, characterized in that if the central directory (PrO) receives a request for access to a first object identified by a logical name identifying a logical access path of said first object from the central directory it searches its data structure for the logical name received in order to send the request directly to said object or, if said logical name is not in its directory, it searches for a logical name with the longest character string equal to a first part of the character string of the logical name received, in order to send to a father object determined in this way the request relating to the first object, by providing said father object with information corresponding to the logical access path of the first object relative to the father object.
3. A method according to claim 2, characterized in that the father object which receives said request sends the request to said first object if it is a son object of its process or returns a message to the central directory.
4. A method according to any preceding claim, characterized in that the central directory manages the redundancy of the processes by selecting one of several processes containing the requested object.
A method according to any preceding claim, characterized in that if a father object of a process receives a request relating to a son object directly it returns that request to the central directory if said son object is not contained in its process.
6. A method according to claim 5, the son object being identified in said request by a logical name defining the logical access path of that object from said father object, characterized in that said father object returns said request to the central directory with the character string of said logical name preceded by the character string corresponding to its own logical name defining its logical access path from WO 00/60452 8 PCT/FROO/00802 the central directory.
7. A method according to any preceding claim, characterized in that the central directory contains at least information relating to each root object of each process.
8. A method according to any preceding claim, characterized in that it applies to a distributed object environment based on a manager of the CORBA type.
9. A method according to any of claims 1 to 7, characterized in that it applies to a distributed object environment based on a manager of the DCOM type.
Applications Claiming Priority (3)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
FR9904072A FR2791788B1 (en) | 1999-04-01 | 1999-04-01 | METHOD FOR IMPLEMENTING A TREE OF DISTRIBUTED OBJECTS |
FR99/04072 | 1999-04-01 | ||
PCT/FR2000/000802 WO2000060452A2 (en) | 1999-04-01 | 2000-03-30 | Method for creating a distributed object tree |
Publications (2)
Publication Number | Publication Date |
---|---|
AU3662900A AU3662900A (en) | 2000-10-23 |
AU747472B2 true AU747472B2 (en) | 2002-05-16 |
Family
ID=9543893
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
AU36629/00A Ceased AU747472B2 (en) | 1999-04-01 | 2000-03-30 | Method for creating a distributed object tree |
Country Status (6)
Country | Link |
---|---|
EP (1) | EP1041498A1 (en) |
JP (1) | JP2002541544A (en) |
AU (1) | AU747472B2 (en) |
CA (1) | CA2333791A1 (en) |
FR (1) | FR2791788B1 (en) |
WO (1) | WO2000060452A2 (en) |
Citations (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
WO1997029421A1 (en) * | 1996-02-05 | 1997-08-14 | Athena Telecom Lab, Inc. | Method and apparatus for object management |
US5689664A (en) * | 1995-04-14 | 1997-11-18 | Microsoft Corporation | Interface sharing between objects |
-
1999
- 1999-04-01 FR FR9904072A patent/FR2791788B1/en not_active Expired - Fee Related
-
2000
- 2000-03-30 JP JP2000609878A patent/JP2002541544A/en active Pending
- 2000-03-30 CA CA002333791A patent/CA2333791A1/en not_active Abandoned
- 2000-03-30 AU AU36629/00A patent/AU747472B2/en not_active Ceased
- 2000-03-30 EP EP00400870A patent/EP1041498A1/en not_active Withdrawn
- 2000-03-30 WO PCT/FR2000/000802 patent/WO2000060452A2/en active IP Right Grant
Patent Citations (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5689664A (en) * | 1995-04-14 | 1997-11-18 | Microsoft Corporation | Interface sharing between objects |
WO1997029421A1 (en) * | 1996-02-05 | 1997-08-14 | Athena Telecom Lab, Inc. | Method and apparatus for object management |
Also Published As
Publication number | Publication date |
---|---|
FR2791788A1 (en) | 2000-10-06 |
WO2000060452A3 (en) | 2001-02-01 |
CA2333791A1 (en) | 2000-10-12 |
EP1041498A1 (en) | 2000-10-04 |
WO2000060452A2 (en) | 2000-10-12 |
AU3662900A (en) | 2000-10-23 |
FR2791788B1 (en) | 2001-06-29 |
JP2002541544A (en) | 2002-12-03 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
EP0479660B1 (en) | Distributed configuration profile for computing system | |
US5892946A (en) | System and method for multi-site distributed object management environment | |
US6173313B1 (en) | Methodology for hosting distributed objects at a predetermined node in a distributed system | |
EP0501610B1 (en) | Object oriented distributed computing system | |
EP0875029B1 (en) | Distributed processing | |
US6470357B1 (en) | System and method of enhanced directory services for telecommunications management network applications | |
US6766335B2 (en) | Method and system for providing object references in a distributed object environment supporting object migration | |
EP0629960B1 (en) | Extendible file system | |
US5838970A (en) | Object-oriented computer environment and related method | |
CA1223968A (en) | Real-time distributed data-base management system | |
EP0278316B1 (en) | Method and system for network management | |
US5761672A (en) | Distributed data base system | |
JP2000503785A (en) | Method and apparatus for updating or changing a network directory | |
US5983226A (en) | System for real-time device data management | |
WO2005048136A2 (en) | Using grid-based computing to search a network | |
US6269378B1 (en) | Method and apparatus for providing a name service with an apparently synchronous interface | |
CA2285205C (en) | System and method for tracking records in a distributed computing system | |
US5799149A (en) | System partitioning for massively parallel processors | |
US5854896A (en) | System for preserving logical partitions of distributed parallel processing system after re-booting by mapping nodes to their respective sub-environments | |
WO1999034288A1 (en) | Software architecture for message processing in a distributed architecture computing system | |
AU747472B2 (en) | Method for creating a distributed object tree | |
CA2095311A1 (en) | Conversation management routine for co-operative processing applications | |
CA2356351A1 (en) | Method and apparatus for dynamic command extensibility in an intelligent agent | |
US9922031B2 (en) | System and method for efficient directory performance using non-persistent storage | |
US5881227A (en) | Use of daemons in a partitioned massively parallel processing system environment |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
FGA | Letters patent sealed or granted (standard patent) |