The Experts below are selected from a list of 729 Experts worldwide ranked by ideXlab platform
Fernando Pedone - One of the best experts on this subject based on the ideXlab platform.
-
1 Tashkent: Uniting Durability with Transaction Ordering for High-Performance Scalable Database Replication
2016Co-Authors: Sameh Elnikety, Steven Dropsho, Fernando Pedone, Università Della Svizzera ItalianaAbstract:In stand-alone databases, the two functions of ordering the Transaction Commits and making the effects of Transactions durable are generally performed in one action, namely in the writing of the commit record to disk. In replicated database systems where all replicas agree on the commit order of update Transactions, these two functions are naturally separated; specifically, the replication middleware determines the global commit order, while database replicas make Transactions durable. The contribution of this paper is to demonstrate that the traditional separation of commit ordering from durability in replicated designs forces update Transactions to be made durable serially to disk, a potentially significant scalability bottleneck. Two solutions are possible: (1) keep durability in the database and pass the global commit order from the replicatio
-
tashkent uniting durability with Transaction ordering for high performance scalable database replication
European Conference on Computer Systems, 2006Co-Authors: Sameh Elnikety, Steven Dropsho, Fernando PedoneAbstract:In stand-alone databases, the functions of ordering the Transaction Commits and making the effects of Transactions durable are performed in one single action, namely the writing of the commit record to disk. For efficiency many of these writes are grouped into a single disk operation. In replicated databases in which all replicas agree on the commit order of update Transactions, these two functions are typically separated. Specifically, the replication middleware determines the global commit order, while the database replicas make the Transactions durable.The contribution of this paper is to demonstrate that this separation causes a significant scalability bottleneck. It forces some of the commit records to be written to disk serially, where in a standalone system they could have been grouped together in a single disk write. Two solutions are possible: (1) move durability from the database to the replication middleware, or (2) keep durability in the database and pass the global commit order from the replication middleware to the database.We implement these two solutions. Tashkent-MW is a pure middleware solution that combines durability and ordering in the middleware, and treats an unmodified database as a black box. In Tashkent-API, we modify the database API so that the middleware can specify the commit order to the database, thus, combining ordering and durability inside the database. We compare both Tashkent systems to an otherwise identical replicated system, called Base, in which ordering and durability remain separated. Under high update Transaction loads both Tashkent systems greatly outperform Base in throughput and response time.
Sameh Elnikety - One of the best experts on this subject based on the ideXlab platform.
-
1 Tashkent: Uniting Durability with Transaction Ordering for High-Performance Scalable Database Replication
2016Co-Authors: Sameh Elnikety, Steven Dropsho, Fernando Pedone, Università Della Svizzera ItalianaAbstract:In stand-alone databases, the two functions of ordering the Transaction Commits and making the effects of Transactions durable are generally performed in one action, namely in the writing of the commit record to disk. In replicated database systems where all replicas agree on the commit order of update Transactions, these two functions are naturally separated; specifically, the replication middleware determines the global commit order, while database replicas make Transactions durable. The contribution of this paper is to demonstrate that the traditional separation of commit ordering from durability in replicated designs forces update Transactions to be made durable serially to disk, a potentially significant scalability bottleneck. Two solutions are possible: (1) keep durability in the database and pass the global commit order from the replicatio
-
tashkent uniting durability with Transaction ordering for high performance scalable database replication
European Conference on Computer Systems, 2006Co-Authors: Sameh Elnikety, Steven Dropsho, Fernando PedoneAbstract:In stand-alone databases, the functions of ordering the Transaction Commits and making the effects of Transactions durable are performed in one single action, namely the writing of the commit record to disk. For efficiency many of these writes are grouped into a single disk operation. In replicated databases in which all replicas agree on the commit order of update Transactions, these two functions are typically separated. Specifically, the replication middleware determines the global commit order, while the database replicas make the Transactions durable.The contribution of this paper is to demonstrate that this separation causes a significant scalability bottleneck. It forces some of the commit records to be written to disk serially, where in a standalone system they could have been grouped together in a single disk write. Two solutions are possible: (1) move durability from the database to the replication middleware, or (2) keep durability in the database and pass the global commit order from the replication middleware to the database.We implement these two solutions. Tashkent-MW is a pure middleware solution that combines durability and ordering in the middleware, and treats an unmodified database as a black box. In Tashkent-API, we modify the database API so that the middleware can specify the commit order to the database, thus, combining ordering and durability inside the database. We compare both Tashkent systems to an otherwise identical replicated system, called Base, in which ordering and durability remain separated. Under high update Transaction loads both Tashkent systems greatly outperform Base in throughput and response time.
Steven Dropsho - One of the best experts on this subject based on the ideXlab platform.
-
1 Tashkent: Uniting Durability with Transaction Ordering for High-Performance Scalable Database Replication
2016Co-Authors: Sameh Elnikety, Steven Dropsho, Fernando Pedone, Università Della Svizzera ItalianaAbstract:In stand-alone databases, the two functions of ordering the Transaction Commits and making the effects of Transactions durable are generally performed in one action, namely in the writing of the commit record to disk. In replicated database systems where all replicas agree on the commit order of update Transactions, these two functions are naturally separated; specifically, the replication middleware determines the global commit order, while database replicas make Transactions durable. The contribution of this paper is to demonstrate that the traditional separation of commit ordering from durability in replicated designs forces update Transactions to be made durable serially to disk, a potentially significant scalability bottleneck. Two solutions are possible: (1) keep durability in the database and pass the global commit order from the replicatio
-
tashkent uniting durability with Transaction ordering for high performance scalable database replication
European Conference on Computer Systems, 2006Co-Authors: Sameh Elnikety, Steven Dropsho, Fernando PedoneAbstract:In stand-alone databases, the functions of ordering the Transaction Commits and making the effects of Transactions durable are performed in one single action, namely the writing of the commit record to disk. For efficiency many of these writes are grouped into a single disk operation. In replicated databases in which all replicas agree on the commit order of update Transactions, these two functions are typically separated. Specifically, the replication middleware determines the global commit order, while the database replicas make the Transactions durable.The contribution of this paper is to demonstrate that this separation causes a significant scalability bottleneck. It forces some of the commit records to be written to disk serially, where in a standalone system they could have been grouped together in a single disk write. Two solutions are possible: (1) move durability from the database to the replication middleware, or (2) keep durability in the database and pass the global commit order from the replication middleware to the database.We implement these two solutions. Tashkent-MW is a pure middleware solution that combines durability and ordering in the middleware, and treats an unmodified database as a black box. In Tashkent-API, we modify the database API so that the middleware can specify the commit order to the database, thus, combining ordering and durability inside the database. We compare both Tashkent systems to an otherwise identical replicated system, called Base, in which ordering and durability remain separated. Under high update Transaction loads both Tashkent systems greatly outperform Base in throughput and response time.
Michel Raynal - One of the best experts on this subject based on the ideXlab platform.
-
Read invisibility, virtual world consistency and permissiveness are compatible
2010Co-Authors: Tyler Crain, Damien Imbs, Michel RaynalAbstract:The aim of a Software Transactional Memory (STM) is to discharge the programmers from the management of synchronization in multiprocess programs that access concurrent objects. To that end, a STM system provides the programmer with the concept of a Transaction. The job of the programmer is to design each process the application is made up of as a sequence of Transactions. A Transaction is a piece of code that accesses concurrent objects, but contains no explicit synchronization statement. It is the job of the underlying STM system to provide the illusion that each Transaction appears as being executed atomically. Of course, for efficiency, a STM system has to allow Transactions to execute concurrently. Consequently, due to the underlying STM concurrency management, a Transaction Commits or aborts. This paper studies the relation between two STM properties (read invisibility and permissiveness) and two consistency conditions for STM systems, namely, opacity and virtual world consistency. Both conditions ensures that any Transaction (be it a committed or an aborted Transaction) reads values from a consistent global state, a noteworthy property if one wants to prevents abnormal behavior from concurrent Transactions that behave correctly when executed alone. A read operation issued by a Transaction is invisible if it does not entail shared memory modifications. This is an important property that favors efficiency and privacy. An STM system is permissive with respect to a consistency condition if it accepts every history that satisfies the condition. This is a crucial property as a permissive STM system never aborts a Transaction “for free”. The paper first shows that read invisibility, permissiveness and opacity are incompatible, which means that there is no permissive STM system that implements opacity while ensuring read invisibility. It then shows that invisibility, permissiveness and opacity are compatible. To that end the paper describes a new STM protocol called IR VWC P. This protocol presents additional noteworthy features: it uses only base read/write objects and locks which are used only at commit time; it satisfies the disjoint access parallelism property; and, in favorable circumstances, the cost of a read operation is O(1).
-
A versatile STM protocol with invisible read operations that satisfies the virtual world consistency condition
2009Co-Authors: Damien Imbs, Michel RaynalAbstract:The aim of a Software Transactional Memory (STM) is to discharge the programmers from the management of synchronization in multiprocess programs that access concurrent objects. To that end, a STM system provides the programmer with the concept of a Transaction. The job of the programmer is to decompose each sequential process the application is made up of into Transactions. A Transaction is a piece of code that accesses concurrent objects, but contains no explicit synchronization statement. It is the job of the underlying STM system to provide the illusion that each Transaction appears as being executed atomically. For efficiency, a STM system allows Transactions to execute concurrently. Consequently, due to the underlying STM concurrency management, a Transaction Commits or aborts. This paper first presents a new STM consistency condition, called virtual world consistency. This condition states that no Transaction reads object values from an inconsistent global state. It is similar to opacity for the committed Transactions but weaker for the aborted Transactions. More precisely, it states that (1) the committed Transactions can be totally ordered, and (2) the values read by each aborted Transaction are consistent with respect to its causal past only. Hence, virtual world consistency is weaker than opacity while keeping its spirit. Then, assuming the objects shared by the processes are atomic read/write objects, the paper presents a STM protocol that ensures virtual world consistency (while guaranteeing the invisibility of the read operations). From an operational point of view, this protocol is based on a vector-clock mechanism. Finally, the paper considers the case where the shared objects are regular read/write objects. It also shows how the protocol can be weakened to satisfy the causal consistency condition (that is weaker than virtual world consistency). Virtual world consistency does not require the aborted Transactions to agree on what they have seen. This is captured by the local vector clocks associated with each process and the vector timestamps associated with each object. From a comprehensive point of view, the paper addresses how the interplay of these local control informations allows the execution of a set of Transactions to be provided with a global meaning.
-
Provable STM Properties: Leveraging Clock and Locks to Favor Commit and Early Abort
2008Co-Authors: Damien Imbs, Michel RaynalAbstract:The aim of a Software Transactional Memory (STM) is to discharge the programmers from the management of synchronization in multiprocess programs that access concurrent objects. To that end, a STM system provides the programmer with the concept of a Transaction: each sequential process is decomposed into Transactions, where a Transaction encapsulates a piece of code accessing concurrent objects. A Transaction contains no explicit synchronization statement and appears as if it has been executed atomically. Due to the underlying concurrency management, a Transaction Commits or aborts. The major part of papers devoted to STM systems address mainly their efficiency. Differently, this paper focuses on an orthogonal issue, namely, the design and the statement of a safety property. The only safety property that is usually considered is a global property involving all the Transactions (e.g., conflictserializability or opacity) that expresses the correction of the whole execution. Roughly speaking, these consistency properties do not prevent a STM system from aborting all the Transactions. The proposed safety property, called obligation, is on each Transaction taken individually. It specifies minimal circumstances in which a STM system must commit a Transaction T. The paper proposes and investigates such an obligation property. Then, it presents a STM algorithm that implements it. This algorithm, which is based on a logical clock and associates a lock with each shared object, is formally proved correct.
-
On the Consistency Conditions of Transactional Memories
2008Co-Authors: Damien Imbs, José Ramón González De Mendivil Moreno, Michel RaynalAbstract:The aim of a Software Transactional Memory (STM) is to discharge the programmers from the management of synchronization in multiprocess programs that access concurrent objects. To that end, a STM system provides the programmer with the concept of a Transaction: each sequential process is decomposed into Transactions, where a Transaction encapsulates a piece of sequential code accessing concurrent objects. A Transaction contains no explicit synchronization statement and appears as if it has been executed atomically. Due to the underlying concurrency management, a Transaction Commits or aborts. Up to now, few papers focused on the definition of consistency conditions suited to STM systems. One of them has recently proposed the opacity consistency condition. Opacity involves all the Transactions (i.e., the committed plus the aborted Transactions). It requires that (1) until it aborts (if ever it does) a Transaction sees a consistent global state of the concurrent objects, and (2) the execution is linearizable (i.e., it could have been produced by a sequential execution -of the same Transactions- that respects the real time order on the non-concurrent Transactions). This paper is on consistency conditions for Transactional memories. It first presents a framework that allows defining a space of consistency conditions whose extreme endpoints are serializability and opacity. It then extracts from this framework a new consistency condition that we call virtual world consistency. This condition ensures that (1) each Transaction (committed or aborted) reads values from a consistent global state, (2) the consistent global states read by committed Transactions are mutually consistent, but (3) the consistent global states read by aborted Transactions are not required to be mutually consistent. Interestingly enough, this consistency condition can benefit lots of STM applications as, from its local point of view, a Transaction cannot differentiate it from opacity. Finally, the paper presents and proves correct a STM algorithm that implements the virtual world consistency condition. Interestingly, this algorithm distinguishes the serialization date of a Transaction from its commit date (thereby allowing more Transactions to commit).
Onur Mutlu - One of the best experts on this subject based on the ideXlab platform.
-
Improving the Performance and Endurance of Persistent Memory with Loose-Ordering Consistency
IEEE Transactions on Parallel and Distributed Systems, 2018Co-Authors: Jiwu Shu, Long Sun, Onur MutluAbstract:Persistent memory provides high-performance data persistence at main memory. Memory writes need to be performed in strict order to satisfy storage consistency requirements and enable correct recovery from system crashes. Unfortunately, adhering to such a strict order significantly degrades system performance and persistent memory endurance. This paper introduces a new mechanism, Loose-Ordering Consistency (LOC), that satisfies the ordering requirements at significantly lower performance and endurance loss. LOC consists of two key techniques. First, Eager Commit eliminates the need to perform a persistent commit record write within a Transaction. We do so by ensuring that we can determine the status of all committed Transactions during recovery by storing necessary metadata information statically with blocks of data written to memory. Second, Speculative Persistence relaxes the write ordering between Transactions by allowing writes to be speculatively written to persistent memory. A speculative write is made visible to software only after its associated Transaction Commits. To enable this, our mechanism supports the tracking of committed Transaction ID and multi-versioning in the CPU cache. Our evaluations show that LOC reduces the average performance overhead of memory persistence from 66.9% to 34.9% and the memory write traffic overhead from 17.1% to 3.4% on a variety of workloads.
-
Loose-Ordering Consistency for Persistent Memory
2018Co-Authors: Jiwu Shu, Long Sun, Onur MutluAbstract:Emerging non-volatile memory (NVM) technologies enable data persistence at the main memory level at access speeds close to DRAM. In such persistent memories, memory writes need to be performed in strict order to satisfy storage consistency requirements and enable correct recovery from system crashes. Unfortunately, adhering to a strict order for writes to persistent memory significantly degrades system performance as it requires flushing dirty data blocks from CPU caches and waiting for their completion at the main memory in the order specified by the program. This paper introduces a new mechanism, called Loose-Ordering Consistency (LOC), that satisfies the ordering requirements of persistent memory writes at significantly lower performance degradation than state-of-the-art mechanisms. LOC consists of two key techniques. First, Eager Commit reduces the commit overhead for writes within a Transaction by eliminating the need to perform a persistent commit record write at the end of a Transaction. We do so by ensuring that we can determine the status of all committed Transactions during recovery by storing necessary metadata information statically with blocks of data written to memory. Second, Speculative Persistence relaxes the ordering of writes between Transactions by allowing writes to be speculatively written to persistent memory. A speculative write is made visible to software only after its associated Transaction Commits. To enable this, our mechanism requires the tracking of committed Transaction ID and support for multi-versioning in the CPU cache. Our evaluations show that LOC reduces the average performance overhead of strict write ordering from 66.9% to 34.9% on a variety of workloads.
-
ICCD - Loose-Ordering Consistency for persistent memory
2014 IEEE 32nd International Conference on Computer Design (ICCD), 2014Co-Authors: Jiwu Shu, Long Sun, Onur MutluAbstract:Emerging non-volatile memory (NVM) technologies enable data persistence at the main memory level at access speeds close to DRAM. In such persistent memories, memory writes need to be performed in strict order to satisfy storage consistency requirements and enable correct recovery from system crashes. Unfortunately, adhering to a strict order for writes to persistent memory significantly degrades system performance as it requires flushing dirty data blocks from CPU caches and waiting for their completion at the main memory in the order specified by the program. This paper introduces a new mechanism, called Loose-Ordering Consistency (LOC), that satisfies the ordering requirements of persistent memory writes at significantly lower performance degradation than state-of-the-art mechanisms. LOC consists of two key techniques. First, Eager Commit reduces the commit overhead for writes within a Transaction by eliminating the need to perform a persistent commit record write at the end of a Transaction. We do so by ensuring that we can determine the status of all committed Transactions during recovery by storing necessary metadata information statically with blocks of data written to memory. Second, Speculative Persistence relaxes the ordering of writes between Transactions by allowing writes to be speculatively written to persistent memory. A speculative write is made visible to software only after its associated Transaction Commits. To enable this, our mechanism requires the tracking of committed Transaction ID and support for multi-versioning in the CPU cache. Our evaluations show that LOC reduces the average performance overhead of strict write ordering from 66.9% to 34.9% on a variety of workloads.