Replicated resource management system for managing resources in a distributed application and maintaining a relativistic view of state

• US 6,233,623 B1
• Filed: 01/11/1996
• Issued: 05/15/2001
• Est. Priority Date: 01/11/1996
• Status: Expired due to Term

• Current Assignee: Google LLC (Alphabet Inc.)
• Original Assignee: Cabletron Systems Incorporated (Extreme Networks, Inc.)
• Inventors: Jeffords, Jason, Dev, Roger
• Primary Examiner(s): Oberley, Alvin E.
• Assistant Examiner(s): COURTENAY III, ST JOHN
• Application Number:
  US08/585,054
• Time in Patent Office: 1,951 Days
• Field of Search: 395/670-678, 711/1-5, 711/100-173, 711/200-221, 709/1, 709/100-108, 709/200-253, 709/300-305, 709/316
• US Class Current: 719/316
• CPC Class Codes: G06F 9/50 Allocation of resources, e.g. of the central processing unit [CPU]

Abstract

A method and apparatus for accessing resource objects contained in a distributed memory space in a communications network, including dividing the distributed memory space into a plurality of memory pools, each pool containing a collection of resource objects, providing a plurality of resource manager objects, each resource manager object having an associated set of memory pools and a registry of network unique identifiers for the resource objects in those pools, and accessing a given resource object via its network identifier. Another aspect of the invention is to provide a relativistic view of state of a plurality of objects, each object generating a state vector representing that object'"'"'s view of its own state and the state of all other objects, each object sending its state vector to other objects, and each object maintaining a state matrix of the state vectors.

Claims

1. A method of accessing resource objects contained in a distributed memory space in a communications network comprising:

dividing the distributed memory space into one or more memory pools, each memory pool comprising a dedicated plurality of segments of the distributed memory space for storing a collection of resource objects, each resource object being a software object having a network unique identifier and containing methods and attributes;

providing a plurality of resource manager objects, each resource manager object having an associated set of memory pools and a registry of the network unique indentifiers for the resource objects in the associated set of memory pools; and

accessing a given resource object via its network unique identifier in the registry of the resource manager object.

2. The method of claim 1, further including providing a plurality of processes to perform a distributed processing function, each process having an associated resource manager object, and the plurality of processes sharing the methods and attributes of the resource objects in at least one associated memory pool in order to provide the distributed processing function.

3. The method of claim 1, further comprising constructing a distributed application, utilizing a plurality of processes located on a plurality of host systems in the network, by providing each process with an application interface to the resource manager objects.

4. The method of claim 1, further including transporting distributable representations of resource objects to the resource manager objects for an associated memory pool.

5. The method of claim 1, wherein each resource object includes one or more methods for changing an attribute'"'"'s value and one or more methods for sending the attribute'"'"'s value to the resource manager objects of the associated memory pool.

6. The method of claim 1, wherein the resource manager objects provide location-independent object-level messaging based on objectOIDs.

7. The method of any one of claims 2 and 3, wherein the processes perform one or more of the following steps:

(a) examine the resource objects;

(b) use the resource objects;

(c) instantiate the resource objects;

(d) delete resource objects from the associated memory pool;

(e) change the attributes of the resource objects;

(f) synchronize the change of attributes of the resource objects;

(g) receive attribute change notifications for the resource objects;

(h) use any one of object level messaging and object level remote procedure calls for any one of steps (a) through (g).

8. The method of any one of claims 1, 2 and 3 wherein the resource manager objects perform one or more of the following steps:

(i) object transport;

(j) object level message delivery;

(k) automatic object replication;

(l) resource manager object synchronization;

(m) failure detection.

9. The method of claim 2, wherein the plurality of processes communicate through object level messaging and object level remote procedure calls.

10. The method of claim 2, further comprising:

assigning ownership of each of the resource objects to any one of the processes, wherein work requested by calling a method of an owned resource object is performed by the process that owns the called resource object.

11. The method of claim 2, wherein each resource manager object maintains state information which is used for one or more of the following:

coordination of work among the processes;

determining validity of data obtained from the processes;

fault detection and isolation;

voting and agreement paradigms.

12. The method of claim 2, wherein the resource manager objects perform process level failure detection.

13. The method of claim 2, wherein the processes are organized in a peer-to-peer configuration.

14. The method of claim 2, wherein ownership of each resource object is assigned to one of the processes, and the work requested by calling a method of an owned resource object is performed by the process that owns the called resource object.

15. The method of claim 2, wherein each memory pool is assigned a pool identifier which is unique across process boundaries.

16. The method of claim 2, wherein each resource manager object is assigned a resource manager object identifier which is unique across process boundaries.

17. The method of claim 3, wherein the distributed application is a network switch control application, and memory pools are provided relating to the following services:

network topology;

policy;

directory; and

calls.

18. The method of claim 3, further comprising applying application specific logic for deriving application specific objects from the resource objects.

19. The method of claim 10, wherein:

if one of the processes fails, the ownership of resource objects of the failed process is automatically reassigned to another one of the processes.

20. The method of claim 10, wherein when a first joining process of a first resource manager object seeks to join a first memory pool, the first memory pool is synchronized by:

the first resource manager object sending a join pool request to the other resource manager objects;

each resource manager object already joined in the first memory pool responding to the request by sending all the resource objects owned by its associated process to the joining process; and

the first resource manager object sending all of the resource objects owned by the joining process to the already joined processes.

21. The method of claim 11, wherein each resource manager object maintains state information for a contact status determination and for its associated memory pools and the resource manager objects synchronize the state information.

22. The method of claim 11, wherein the state information forms a state matrix and synchronization requires the state matrix to be determinant.

23. The method of claim 11, wherein each resource manager object maintains a relativistic view of state based upon state information received from other resource manager objects.

24. The method of claim 14, wherein the network unique identifier is an object identifier (OID) that is unique across process boundaries, and the OID comprises:

PoolOID.ServiceAddress.InstanceID where;

PoolOID identifies the memory pool which contains the resource object;

ServiceAddress identifies the process that created the resource object; and

InstanceID is a unique ID identifying an instance of an object under the prefix given by PoolOID.

25. The method of claim 14, wherein upon failure of one of the processes, each resource object owned by the failed process calls an ownership arbitration method in order to assign ownership to another process.

26. The method of claim 14, wherein object ownership is reassigned in order to redistribute the processing load.

27. The method of claim 14, wherein object ownership is reassigned in order to allow a resource manager object to leave an associated memory pool.

28. In a communications network having a distributed memory space in a plurality of hosts, apparatus for managing the distributed memory space comprising:

the distributed memory space being divided into a plurality of memory pools, each memory pool comprising a dedicated plurality of segments of the distributed memory for storing a collection of resource objects, each resource object being a software object having a network unique identifier and containing methods and attributes; and

a plurality of resource manager objects located on different hosts in the network, each resource manager object having an associated set of memory pools and a replicated set of resource objects for the associated memory pools.

29. In a distributed computing method, wherein a number of cooperating processes require access to resource objects, the improvement comprising:

a) providing a distributed memory space containing resource objects;

b) providing a plurality of pool objects, each pool object identifying an associated set of resource objects for dividing the resource objects in the distributed memory space into pools, wherein each pool comprises a plurality of dedicated segments of the distributed memory;

c) providing each cooperating process with a resource manager object object, each resource manager object object identifying an associated set of pools in which the cooperating process requires access to the contained resource objects;

d) each resource manager object object replicating the resource objects in its associated set of pools and providing access by the cooperating process to the replicated resource objects; and

e) each resource manager object object synchronizing its state with the other resource manager object objects.

30. The method of claim 29, further comprising the step of:

storing the resource objects in a persistent storage medium.

31. The method of claim 29, wherein the synchronizing step includes:

determining whether the resource manager object object is in an active state.

32. The method of claim 31, wherein the synchronizing step includes:

determining the state of the pool objects.

33. The method of claim 29, further comprising:

assigning ownership of each resource object to any one of the processes, wherein the owning process is responsible for the work performed by the owned resource object.

34. The method of any one of claims 29 and 32, wherein the determining step includes:

generating a state vector comprising the object'"'"'s view of itself and relative view of other objects.

35. The method of claim 32, wherein the synchronizing step includes:

determining the state of the resource objects.

36. The method of claim 33, further comprising the step of:

a cooperating process leaving the computing function by sending a leave pool message to the resource manager objects already joined to the pool.

37. The method of claim 33, further comprising the step of:

the resource manager objects determining a distribution of workload among the processes.

38. The method of claim 33, further comprising the step of:

a new cooperating process joining the computing function by sending a join pool message to the resource manager objects.

39. The method of claim 34, wherein the determining step comprises:

determining whether the state vector is determinant.

40. The method of claim 34, wherein the determining step comprises:

generating a state matrix of state vectors.

41. The method of claim 34, further comprising:

applying application specific logic to the state vectors by derivation to provide application specific state vectors.

42. The method of claim 40, wherein the determining step comprises:

determining whether the state matrix is determinant.

43. The method of claim 40, further comprising:

applying application specific logic to the state matrices by derivation for providing application specific state matrices.

44. The method of claim 43, further comprising:

determining the contact status of the cooperating processes from the application specific state matrices.

45. Apparatus for performing a distributed computing function in a system having a plurality of hosts, each host having a local processer and memory apportioned into one or more pools, where each pool comprises a dedicated plurality of segments of the memory, the apparatus comprising:

a first host including a first process and a first resource manager object which identifies one or more pools containing resource objects which the first process requires access to;

a second host including a second process and a second resource manager object which identifies one or more pools containing resource objects which the second process requires access to; and

each resource object being contained in the local memory of the host having the process which requires access to the resource object;

wherein each of the first and second processes can access the resource object in local memory contained in the same host as the process.

46. In a system comprising a plurality of hosts and a connection device for enabling communication between the hosts, each host having a local processor and local memory apportioned into one or more pools, each pool comprising a dedicated plurality of segments of the local memory, and the combined local memories comprising a distributed memory space, a software system for enabling the hosts to perform a distributed computing function comprising:

a plurality of cooperating processes contained on different hosts;

each cooperating process having a resource manager object identifying an associated set of pools in which the cooperating process requires access;

a plurality of pool objects for dividing the distributed memory space into pools, each pool object identifying an associated set of resource objects contained in the distributed memory space; and

each host which contains a cooperating process having the pool objects and the resource objects to which the cooperating process requires access.