Flexible state sharing and consistency mechanism for interactive applications

• US 6,058,416 A
• Filed: 05/22/1998
• Issued: 05/02/2000
• Est. Priority Date: 05/22/1998
• Status: Expired due to Fees

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Bhola, Sumeer Kumar, Mukherjee, Bodhi, Doddapaneni, Srinivas Prasad
• Primary Examiner(s): Lim, Krisna
• Application Number:
  US09/083,669
• Time in Patent Office: 711 Days
• Field of Search: 709/203, 709/205, 709/303, 707/103
• US Class Current: 709/203
• CPC Class Codes: G06F 9/52 Program synchronisation; Mutual exclusion, e.g. by means of semaphores
• CPC Class Codes: G06F 9/542 Event management; Broadcasting; Multicasting; Notifications

Abstract

A system, method and computer program storage device providing event and/or state sharing support e.g., for building object-oriented interactive groupware in wide-area distributed environments (such as the Internet). For collaborative applications programmed using events, mechanisms are provided for sharing application-specific events. For example: an event based programming model allows applications to post an event and triggers corresponding ERUs (Event Reaction Unit) in reaction to a received event; preconditions for control activation of ERUs; and event consistency policy objects implement application specified event consistency model. Some policy examples are: a policy in which event order is not guaranteed, but all events are guaranteed to be sent to the ERUs eventually; and a policy that first triggers local ERUs and then posts the event to the server. An out-of-order event is detected using the event notification from the server; and an automatic detection of out-of-order events seen by ERUs in the local workstation in this optimistic event execution model. For applications requiring support for state sharing, an asynchronous model for updating replicated state, which supports atomicity of updates across multiple shared objects is described. Coupled with a flexible marshaling framework, this allows existing application data-structure classes to be easily extended and made shareable. To solve the problem of replica consistency, a novel combination of three mechanisms is used: global locks; detection of incorrect update ordering; and cloning a subset of the shared objects for state re-initialization. To reduce network load due to fine-grained user interaction, a framework for application specified event batching, called Late Event Modification (LEM), enhances the event interface to allow applications to modify the event objects after posting them to the set.

Claims

1. A system for updating replicated state in a distributed collaborative application, comprising:

a plurality of clients, each client comprising;

the distributed collaborative application comprising one or more distributable components, wherein each component may be executed independently and communicate with other components;

each component including one or more sets of related shared objects which are replicated at collaborating applications; and

a collaborative client middleware, communicatively coupled to the application and to the network, adapted to communicate to and receive updates over the network to the state of a shared object;

conflict detection means for detecting conflicting updates to the shared object; and

conflict resolution means for resolving said conflicts, detachably coupled to the conflict detection means.

2. The system of claim 1, further comprising update event means for asynchronously and atomically updating one or more of said related shared objects.

3. The system of claim 1, further comprising add object means for adding an object to a local set replica of said shared objects and communicating an added object state to collaborating applications.

4. The system of claim 1, further comprising means for instantiating a collaborative team.

5. The system of claim 4 wherein the system includes a client-server system, further comprising:

an optimistic event execution model; and

team descriptor logic means for ordering events through the server and dispatching locally generated events immediately.

6. The system of claim 1, wherein the system is a client-server system, further comprising:

a server coupled to the network, the server comprising means for maintaining a collaborative activity for each active collaboration.

7. The system of claim 6, the server further comprising:

team server means for dynamically creating, updating and destroying a collaborative team, wherein each team has a unique name space in a collaborative activity.

8. The system of claim 6, the server further comprising team policy means for defining and implementing a team behavior.

9. The system of claim 1, further comprising context-sensitive state marhalling means for propagating state to one or more new or updated shared objects in the shared object sets.

10. The system of claim 1, further comprising

cloning and reinitialization means for correcting diverging state among the shared object sets.

11. The system of claim 10, further comprising:

context-sensitive state marhalling means for marshaling and unmarshaling clones of one or more shared objects in the shared object sets.

12. The system of claim 10, wherein said cloning and reinitializing means further comprises:

clone subsetting means for making a clone of a subset of objects in the set and preserving pointers from inside the original subsets to objects outside the cloned subset;

means for mapping references between objects inside the original subset into the cloned subset;

means for exporting the cloned subset to other clients; and

means for reinitializing the subset of objects based one of the cloned subsets.

13. The system of claim 1, wherein the events are the units of communication in the collaborative client, and each event has a name, a type, data, and a source.

14. The system of claim 13, wherein the collaborative client further comprises:

means for instantiating a collaborative team; and

team descriptor logic means for ordering of events posted to a team and dispatching of received events.

15. The system of claim 14, further comprising:

an optimistic event execution model; and

team descriptor logic means for ordering events through the server and dispatching locally generated events immediately.

16. The system of claim 15, said conflict detection means further comprising means for detecting an out-of-order event based on an event notification received from the server.

17. The system of claim 1, wherein the events are the units of communication in the collaborative client, further comprising:

Late Event Modification (LEM) means for batching and modifying events after posting them to the shared set.

18. The system of claim 1, said conflict detection means further comprising means for detecting conflicts due to incorrectly ordered updates to the shared object and informing the application.

19. In a distributed collaborative application wherein one or more distributable components may be executed independently and communicate with other components, each component including one or more sets of replicated shared objects, a method for updating replicated state, comprising the steps of:

a client communicating updates to and receiving updates to the state of a shared object;

detecting diverging state among the shared object sets; and

cloning and reinitializing the state among the shared object sets, in response to said detecting.

20. The method of claim 19, said detecting step further comprising the steps of:

detecting conflicts due to incorrectly ordered updates to the shared object; and

informing the application, in response to said detecting step.

21. The method of claim 19, further comprising the step of:

marhalling and unmarshaling clones of one or more shared objects in the shared object sets.

22. The method of claim 19, wherein said cloning and reinitializing step further comprises the steps of:

making a copy of a subset of objects in the set and preserving pointers from inside the original subsets to objects outside the cloned subset;

mapping references between objects inside the original subset into the cloned subset;

exporting the cloned subset to other clients; and

re-initializing the subset of objects based on the cloned subset, in response to said exporting step.

23. The method of claim 19, further comprising the steps of:

marhalling and propagating context-sensitive state to one or more new or updated shared objects in the shared object sets.

24. The method of claim 19, wherein the system is a client-server system, further comprising the steps of:

said receiving step comprising receiving a shared event from the server; and

detecting an out-of-order event based on the shared event received from the server.

25. The method of claim 19, wherein the system is a client-server system, each client further comprises a collaborative client middleware, communicatively coupled to the application and to the network.

26. A program storage device readable by a machine, tangibly embodying a program of instructions executable by the machine to perform method steps for a method for updating replicated state in a distributed collaborative application wherein one or more distributable components may be executed independently and communicate with other components, each component including one or more sets of replicated shared objects, said method comprising the steps of:

a client communicating updates to and receiving updates to the state of a shared object;

detecting diverging state among the shared object sets; and

cloning and reinitializing the state among the shared object sets, in response to said detecting.

27. The program storage device of claim 26, wherein each client comprises a collaborative client middleware, communicatively coupled to the application and to a network.

28. The program storage device of claim 26, wherein the system is a client-server system, further comprising the steps of dynamically creating, updating and destroying a collaborative team, wherein each team has a unique name space in a collaborative activity on the server.

29. The program storage device of claim 28, further comprising the step of defining and implementing a team behavior based on a team policy.

30. The program storage device of claim 26, further comprising the steps of:

said detecting diverging state comprising the step of detecting conflicts due to incorrectly ordered updates to a shared object; and

informing the application, in response to said detecting step.

31. The program storage device of claim 26, further comprising the step of:

marhalling and propagating context-sensitive state to one or more new or updated shared objects in the shared object sets.

32. The program storage device of claim 26, further comprising the step of:

marhalling and unmarshaling clones of one or more shared objects in the shared object sets.

33. The program storage device of claim 26, wherein said cloning and reinitializing step further comprises the steps of:

making a copy of a subset of objects in the set and preserving pointers from inside the original subsets to objects outside the cloned subset;

mapping references between objects inside the original subset into the cloned subset;

exporting the cloned subset to other clients; and

re-initializing the subset of objects based on the cloned subset, in response to said exporting step.

34. The program storage device of claim 26, wherein the events are the units of communication in the collaborative client, the method further comprising the steps of:

posting an event to the shared object set;

batching and modifying events after posting them to the shared object set; and

marhalling and propagating context-sensitive state to one or more new or updated shared objects in the shared object sets.