Scalable information sharing in large scale distributed systems

• Authors: Mustaque Ahamad;Sumeer Bhola;Rammohan Kordale;Francisco Torres-Rojas
• Venue: EW 7 Proceedings of the 7th workshop on ACM SIGOPS European workshop: Systems support for worldwide applications
• Year: 1996

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 ol to produce version o1,1 and later generates its updated version ol,2. User 2 reads ol,2 and writes memo object o2 in response. If user 3 reads memo o2 and wants to read o1 to understand it, it must be provided ol,2 and not o1,1 which could have been cached by it due to a previous read. Thus, consistency requirements exist across copies of ol and o2 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.