scalable information sharing in large scale distributed systems
Many application domains have already demonstrated that they can benefit greatly if efficient access can be provided to shared information across widely distributed users. We use the generic term object to describe units of shared information which could include files, web pages or language defined objects. Future applications will require object sharing modes richer than simple browsing. For example, a collaboration system that allows users distributed world-wide (e.g., managers of a multinational company) to interact with each other must manipulate objects that are both read and updated at multiple locations.Several assumptions, which are natural in the context of large scale systems, can be made about scalable object sharing systems. First, such systems will consist of many server nodes that will act as the storehouses for shared objects. These servers will enable access to objects to a much larger number of client nodes. To avoid high latencies and communication costs, servers will store replicated copies of objects frequently accessed by clients in their vicinity. Furthermore, clients will cache objects to reduce access latency and frequency of communication with servers. Both replication at servers and caching at clients result in multiple copies of an object which introduces the problem of maintaining consistency among the copies.Many levels of consistency are possible and the choice of a particular consistency level has implications on the programming as well as performance of a distributed application. Although consistency requirements across copies of a single object are easily seen, such requirements can arise between copies of different but related objects. For example, assume that user 1 writes a memo object o l to produce version o 1,1 and later generates its updated version o l,2 . User 2 reads o l,2 and writes memo object o 2 in response. If user 3 reads memo o 2 and wants to read o 1 to understand it, it must be provided o l,2 and not o 1,1 which could have been cached by it due to a previous read. Thus, consistency requirements exist across copies of o l and o 2 even when user 3 accesses them in a read-only mode.We first identify some requirements that must be met by scalable object sharing schemes. We present arguments to demonstrate that existing techniques cannot easily be adapted to meet these requirements. This is followed by an outline of our approach.
scalability information share informal sharing distributed systems distributed systems applications domain read demonstrate efficiency access use user user generic object web page language future requirements browse examples collaboration system management locatability context consistency server latency communication replication cache cache program performance distributed application version response scheme argument large-scale users caches