In a Distributed System with N sites, the precise detection of causal relationships between events can only be done with vector clocks of size N. This gives rise to scalability and efficiency problems for logical clocks that can be used to order events accurately. In this paper we propose a class of logical clocks called plausible clocks that can be implemented with a number of components not affected by the size of the system and yet they provide good ordering accuracy. We develop rules to combine plausible clocks to produce more accurate clocks. Several examples of plausible clocks and their combination are presented. Using a simulation model, we evaluate the performance of these clocks. We also present examples of applications where constant size clocks can be used.

Plausible clocks: constant size logical clocks for distributed systems

Ordering and time are two different aspects of consistency of shared objects in a distributed system. One avoids conflicts between operations, the other addresses how quickly the effects of an operation are perceived by the rest of the system. Consistency models such as sequential consistency and causal consistency do not consider the particular time at which an operation is executed to establish a valid order among all the operations of a computation. Timed consistency models require that if a write operation is executed at time t, it must be visible to all nodes by time t +Δ. Timed consistency generalizes several existing consistency criteria and it is well suited for interactive and collaborative applications, where the action of one user must be seen by others in a timely fashion.

Timed consistency for shared distributed objects

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.

Flexible state sharing and consistency mechanism for interactive applications

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, while providing support for context-sensitive state marshaling applications. 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.

Flexible event sharing, batching, and state consistency mechanisms for interactive applications

This paper discusses the implementation of CASCADE, a distributed caching service for CORBA objects. Our caching service is fully CORBA compliant, and supports caching of active objects, which include both data and code. It is specifically designed to operate over the Internet by employing a dynamically built cache hierarchy. The service architecture is highly configurable with regard to a broad spectrum of application parameters. The main benefits of CASCADE are enhanced availability and service predictability, as well as easy dynamic code deployment and consistency maintenance.

/pdf/implementing-a-caching-service-for-distributed-corba-objects-ads58xi77v.pdf

Implementing a Caching Service for Distributed CORBA Objects

Distributed object systems provide the key to build large scale applications that can execute on a range of platforms. The Common Object Request Broker Architecture (CORBA) specification from OMG attempts to address interoperability and heterogeneity issues that arise in such systems. Our goal is to investigate performance issues for distributed object systems. We claim that object caching is a must for improved performance and scalability in distributed object systems. However, to our knowledge, the CORBA specification does not address object caching. The purpose of this paper is to serve as a data point in a discussion of issues related to caching in CORBA by describing the design and implementation of Flex, a scalable and flexible distributed object caching system. Flex is built on top of Fresco that uses the CORBA object model. Fresco runs on the UNIX operating system and our implementation of Flex exploits the features of object technology, Fresco and UNIX. This system allows us to quantify the performance improvements for object invocations that are made possible by caching.

/pdf/object-caching-in-a-corba-compliant-system-vajiosofbj.pdf

Object Caching in a CORBA Compliant System.

Object caching in a CORBA compliant system

In large scale distributed systems, caching and replication could greatly speedup access and increase availability. Consistency of replicated state can be guaranteed by forcing operations to occur in the same order at all sites. However some applications can preserve correctness with weaker consistency requirements leading to better performance. We propose an object lifetime based mutual consistency detection mechanism that is used to implement multiple consistency levels. This mechanism provides scalable implementations because caching overheads at client nodes depend only on the accesses done at the node. A contribution of this paper is the separation of the the mutual consistency detection mechanism from the policy that decides the desired consistency guarantees. This allows multiple consistency levels to coexist, thus improving system performance through the use of weaker consistency levels when possible. Besides improving performance, the mechanism allows for a graceful weakening of consistency requirements when stronger requirements cannot be maintained, as in the case of disconnection that can be experienced in mobile environments. The mutual consistency detection mechanism also provides a uniform way of hoarding a mutually consistent set of objects during voluntary disconnection.

A scalable technique for implementing multiple consistency levels for distributed objects

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.

Scalable information sharing in large scale distributed systems

In this thesis, we investigate system support for meeting scalable sharing requirements of large scale and mobile applications. In particular, we are interested in measuring scalability along the two dimensions of system load and geographic distribution. A common way to address such requirements is to employ server replication and client caching which introduces the problem of consistency among multiple copies of an object. The performance and functionality of such a system could depend very much on the consistency protocol implemented by the system.
We take a two-pronged approach to meet the requirements of scale. Firstly, we recognize that weaker levels of consistency can be implemented more efficiently. Moreover, strong consistency cannot always be provided in systems where clients are temporarily "disconnected" which can happen involuntarily or voluntarily in mobile systems. Thus, we take the approach of allowing object (application) implementors to choose from a variety of consistency levels.
We build scalable implementations of the various consistency policies by using a novel mechanism called mutual consistency. The basic idea of the mutual consistency mechanisms can be summarized as follows. In traditional protocols, nodes that update shared state take the responsibility of notifying interested parties about the updates. When interested parties are widely distributed, latency of access in such systems can be very large. In mutual consistency based protocols, however, nodes that update shared state do not take the responsibility of notifying interested parties about the updates; instead, nodes only ensure that they learn of external updates to objects they access in a consistent manner.
To address heterogeneity issues, we built our object caching framework on top of a system that follows the COBRA (Common Object Request Broker Architecture) object model. The performance results support our hypotheses. Weaker consistency levels could be implemented more efficiently than stronger consistency levels. Moreover, the mutual consistency based strong consistency protocol scaled better than the traditional protocol along both dimensions of scalability. The traditional protocol entailed 50% more messages and 15% more server load per client and was 39% slower (in terms of average response times) than the mutual consistency based strong consistency protocol.

System support for scalable services

Handle everyday research tasks with reliable, citation-backed results

Your personal Research Agent to handle research tasks with citation-backed results

Popular Tasks used by Researchers

How can I help with your research?

Meet SciSpace

Get more enhanced response by uploading the PDFs you want me to reference.

No relevant PDFs in your library

SciSpace is the AI research assistant for academics. Run systematic literature reviews on 280M+ papers, and write papers with cited sources. Trusted by 1M+ students, PhDs & researchers.

SciSpace | AI for Research

Analyze PDFs

Code & Manuscripts

Funding & Grants

Literature & Patents

Medical & Clinical Data

Systematic Review

Visualize & Present

Web & Data

Build a Google Scholar-like website for your research.

Build a website

Create charts and images for your research

Create a Chart

Write a paper for submission to a journal

Draft a manuscript

Patent Search

Design eye-catching scientific posters in minutes.

Scientific Poster Generation

Systematic Literature Review

One task is running at the moment. Your messages will be shown right after.

Drag and drop or click here to browse

Loved by <highlight>1 million+</highlight> researchers

Extract a list of specific topics and their sources from unstructured text

Topics

Compare and analyze relevant papers that matches with your search

Papers

Get insights from PDFs and bookmarked papers from your library

My library

Recent searches

Try searching for:

Catch AI-generated content in scholarly and non-scholarly content

{ai} Detector

Ai Writer

Get PDF Summaries, highlighted text explanations 

Chat with PDF

Effortlessly create in-text citations and bibliographies in APA and 2,500 other formats

Citation generator

Get explanations, summaries, and answers on academic papers

Ease up your research workflow with {scispace}'s cohort of exciting AI tools

Elevate your academic writing skills and convey your ideas the way you want

Paraphraser

Explore our range of reading and writing tools

Your file is being prepared and should be ready in a few minutes. If it's a large file, it might take a bit longer. You can close this window, and we'll email you the file when it's done.

You have reached a maximum limit of <strong>{limit}</strong> columns in the table. Remove at least <strong>1</strong> column to add or create another one.

Rammohan Kordale

Author Tools

Chat about Author