Lazy caching

Afek, Yehuda; Brown, Geoffrey; Merritt, Michael

doi:10.1145/151646.151651

Cited by 92 publications

(94 citation statements)

References 8 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…For simplicity, in both cases we consider, as in [3,5,8,18,24,26,25], that each MCSprocess has a copy (replica) of the whole shared memory. In an MCS with invalidation, some of the copies of a variable x can be "invalid" or outdated.…”

Section: Systemmentioning

confidence: 99%

See 1 more Smart Citation

Decoupled Interconnection of Distributed Memory Models

Jiménez

Fernández

Cholvi

2004

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Abstract. In this paper we present a framework to formally describe and study the interconnection of distributed shared memory systems. In our models we minimize the dependencies between the original systems and the interconnection system (that is, they are decoupled) and consider systems implemented with invalidation and propagation. We first show that only fast (i.e. wait-free) memory models can be interconnected. We then show that causal and pRAM systems can be interconnected if they fulfill some restrictions, and for these cases, we present protocols to interconnect them. Finally, we present a protocol to interconnect cache systems.

show abstract

Section: Systemmentioning

confidence: 99%

“…This value is returned to an application process that issues a read operation. New written values are propagated among MCS-processes to maintain the copies up to date [3,5,8,18]. …”

Section: Systemmentioning

confidence: 99%

Decoupled Interconnection of Distributed Memory Models

Jiménez

Fernández

Cholvi

2004

Lecture Notes in Computer Science

View full text Add to dashboard Cite

show abstract

“…Consequently, previous theorem-proving approaches have not been able to verify a problem of the scale of a full multiprocessor cache coherence protocol. The most significant result before our work is a manual proof of "lazy caching," a simple and abstract cache coherence algorithm [2], [13], [21]. It should be noted that using a theorem-prover typically increases the labor required to complete a proof compared with manual proof-however, the results are much more likely to be correct.…”

Section: Basic Ideamentioning

confidence: 99%

“…There are two interpretations for what it means for a distributed memory to be sequentially consistent [23], [7], [2]. The first is that every terminating multiprocessor program must produce one of the possible "results" (contents of memory and registers) that could be produced by a multiprocessor with a single shared atomic memory.…”

Section: Delayed Mode Conforms To Sequential Consistency Memory Modelmentioning

confidence: 99%

Verification of Cache Coherence Protocols by Aggregation of Distributed Transactions

Park

Dill

1998

Theory of Computing Systems

View full text Add to dashboard Cite

Abstract. This paper presents a method to verify the correctness of protocols and distributed algorithms. The method compares a state graph of the implementation with a specification which is a state graph representing the desired abstract behavior. The steps in the specification correspond to atomic transactions, which are not atomic in the implementation.The method relies on an aggregation function, which is a type of abstraction function that aggregates the steps of each transaction in the implementation into a single atomic transaction in the specification. The key idea in defining the aggregation function is that it must complete atomic transactions which have committed but are not finished. This paper illustrates the method on a directory-based cache coherence protocol developed for the Stanford FLASH multiprocessor. The coherence protocol consisting of more than a hundred different kinds of implementation steps has been reduced to a specification with six kinds of atomic transactions. Based on the reduced behavior, it is very easy to prove crucial properties of the protocol including data consistency of cached copies at the user level. This is the first correctness proof verified by a theorem-prover for a cache coherence protocol of this complexity. The aggregation method is also used to prove that the reduced protocol satisfies a desired memory consistency model.

show abstract

“…RELATED WORK Several protocols providing a sequentially consistent shared memory abstraction on top of an asynchronous message passing distributed system have been proposed. The protocol described in [2] implements a sequentially consistent shared memory abstraction on top of a physically shared memory and local caches. It uses an atomic n-queue update primitive.…”

Section: Introductionmentioning

confidence: 99%

A Methodological Construction of an Efficient Sequentially Consistent Distributed Shared Memory

Cholvi

Fernández

Jiménez

et al. 2009

The Computer Journal

View full text Add to dashboard Cite

The paper proposes a simple protocol that ensures sequential consistency. The protocol assumes that the shared memory abstraction is supported by the local memories of nodes, that can communicate only by exchanging messages through reliable channels. Unlike other sequential consistency protocols, the one proposed here does not rely on a strong synchronization mechanism, such as an atomic broadcast primitive or a central node managing a copy of every shared object. From a methodological point of view, the protocol is built incrementally starting from the very definition of sequential consistency. It has the noteworthy property that a process that issues a write operation never has to wait for other processes. Depending on the current local state, most read operations issued also have the same property.Keywords: Distributed Systems, Distributed Shared Memory, Sequential Consistency. I. INTRODUCTIONThe definition of a consistency criterion is crucial for the correctness of a multiprocess program [10], [23]. Basically, a consistency criterion defines which value has to be returned when a read operation on a shared object is invoked by a process [11], [14], [18]. The strongest (i.e., most constraining) consistency criterion is atomic consistency [20], also called linearizability [13]. It states that a read returns the value written by the latest preceding write, "latest" referring to real-time occurrence order (concurrent writes being totally ordered). Causal consistency [3], [5] is a weaker criterion, stating that a read does not get an overwritten value. Causal consistency allows concurrent writes; consequently, it is possible that concurrent read operations on the same object get different values. This occurs when those values have been produced by concurrent writes. Other consistency criteria weaker than causal consistency have also been proposed [1], [27]. This paper focuses on sequential consistency [16]. This criterion lies between atomic consistency and causal consistency. Informally, it states that a multiprocess program executes correctly if its results could have been produced by executing that program on a single processor system. This means that an execution is correct if we can totally order its operations in such a way that 1) The order of operations in each process is preserved, and 2) Each read operation obtains the latest previously written value, "latest" referring here to the total order. The difference between atomic consistency and sequential consistency lies in the meaning of the word "latest". This word refers to real-time when we consider atomic consistency, while it refers to a logical time notion when we consider sequential consistency. Namely, the logical time defined by the total order.

show abstract

Lazy caching

Cited by 92 publications

References 8 publications

Decoupled Interconnection of Distributed Memory Models

Decoupled Interconnection of Distributed Memory Models

Verification of Cache Coherence Protocols by Aggregation of Distributed Transactions

A Methodological Construction of an Efficient Sequentially Consistent Distributed Shared Memory

Contact Info

Product

Resources

About