Dynamic synchronization in non-multimedia collaborative applications

What is it?

• Changing levels of synchronization dynamically depending on system performance
• When do we see the actions of other users ?

Levels of synchronization

When are the different applications synchronized in collaborative applications? Do all users see the changes made by other users immediately or is there a delay between updates? When does this matter? All these questions are related to to keeping shared objects (both view and model) consistent. This notion of synchronization is interrelated to how objects are shared in collaborative applications.

For example, if floor control is used as the concurrency model for both read and write (like xtv), then synchronization is not much of an issue. Since only one person can input any action at any one time, the action should be seen by all views as soon as possible.

However, if you have fine grained concurrency control with locks for changes (like the spreadsheet application), then there are different times when synchronization can happen. In the spreadsheet application, they called this coupling. They separate out the import (when you see the changes made by other users) and export (when other users see the changes made by you) aspect of synchronization. The spreadsheet application supports two levels of synchronization for each dimension: all (after every keystroke) and committed (after an implicit commit by the user - the cursor is moved to another cell). There are other possible levels of synchronization when using locks. For example, when getting or releasing a lock. If locks are used in the collaboration model, it can be seen as implicit notification of potential changes.

On the other end, some collaborative applications can let multiple users make changes to the same objects at any time, then merge the changes. Synchronization could be different in this context because changes have a different meaning. Do you see only the final results of the merging? Or do you see all the individual changes? And when will changes get merged? When will they be seen?

• Synchronization is interrelated to how objects are shared in collaborative applications
• Normally, synchronization is more relevant to "writes" (changes) made to shared objects and not "reads" (viewing). However, depending on the type of collaboration, reads might be synchronized as well.
• Dimensions of synchronization
  • Import: the viewer determines what and when he/she will see the actions of other users.
  • Export: the person making changes will determine what and when he/she will let other users see their actions.
• Possible levels of synchronization
  • Immediately after any event
  • After an implicit commit (for example: when the return key is pressed or locks are acquired or released)
  • After a user determined commit
  • After a predefined time interval
  • After a variable time interval (maybe changed as a function of system performance)

Measuring system performance

• There are two elements in system performance: the processor and the network.
• Measuring network performance seems to be more relevant to this issue.
• Most measurement of network load is done heuristically. For example, in TCP lost packets are used to set window size and in media scaling algorithms the length of buffer queue is used.
• Goopeel Chung (chungg@cs.unc.edu) is doing some work on measuring performance for migration. He is doing experiments by measuring response time under different conditions.

Methods of coupling levels of synchrony with system performance

• Synchronization done automatically
• Synchronization done explicitly by the user
• Notifying the user of system performance to let the user decide on when to synchronize

Papers

• Coupling the User Interfaces of a Multiuser Program

Other Issues

• In the Spreadsheet example, you might try dynamically changing the delay time of the thread depending on the network latency.
  

Return to main page