Searcharxiv⌕ Search

arXiv subjects

Sathya Peri

Publications and source records attributed to Sathya Peri.

43 records · Page 3Linked to original sources
arXiv2016

Multiversion Altruistic Locking

This paper builds on altruistic locking which is an extension of 2PL. It allows more relaxed rules as compared to 2PL. But altruistic locking too enforces some rules which disallow some valid schedules (present in VSR and CSR) to be passed by AL. This paper proposes a multiversion variant of AL which solves this problem. The report also discusses the relationship or comparison between different protocols such as MAL and MV2PL, MAL and AL, MAL and 2PL and so on. This paper also discusses the caveats involved in MAL and where it lies in the Venn diagram of multiversion serializable schedule protocols. Finally, the possible use of MAL in hybrid protocols and the parameters involved in making MAL successful are discussed.

cs.DC↗
arXiv2015

Opacity Proof for CaPR+ Algorithm

In this paper, we describe an enhanced Automatic Check- pointing and Partial Rollback algorithm(CaP R + ) to realize Software Transactional Memory(STM) that is based on con- tinuous conflict detection, lazy versioning with automatic checkpointing, and partial rollback. Further, we provide a proof of correctness of CaP R+ algorithm, in particular, Opacity, a STM correctness criterion, that precisely captures the intuitive correctness guarantees required of transactional memories. The algorithm provides a natural way to realize a hybrid system of pure aborts and partial rollbacks. We have also implemented the algorithm, and shown its effectiveness with reference to the Red-black tree micro-benchmark and STAMP benchmarks. The results obtained demonstrate the effectiveness of the Partial Rollback mechanism over pure abort mechanisms, particularly in applications consisting of large transaction lengths.

cs.DC↗
arXiv2015

Multi-threaded Graph Coloring Algorithm for Shared Memory Architecture

In this paper, we present multi-threaded algorithms for graph coloring suitable to the shared memory programming model. We modify an existing algorithm widely used in the literature and prove the correctness of the modified algorithm. We also propose a new approach to solve the problem of coloring using locks. Using datasets from real world graphs, we evaluate the performance of the algorithms on the Intel platform. We compare the performance of the sequential approach v/s our proposed approach and analyze the speedup obtained against the existing algorithm from the literature. The results show that the speedup obtained is consequential. We also provide a direction for future work towards improving the performance further in terms of different metrics.

cs.DC↗
arXiv2015

Multiversion Conflict Notion for Transactional Memory Systems

In recent years, Software Transactional Memory systems (STMs) have garnered significant interest as an elegant alternative for addressing concurrency issues in memory. STM systems take optimistic approach. Multiple transactions are allowed to execute concurrently. On completion, each transaction is validated and if any inconsistency is observed it is aborted. Otherwise it is allowed to commit. In databases a class of histories called as conflict-serializability (CSR) based on the notion of conflicts have been identified, whose membership can be efficiently verified. As a result, CSR is the commonly used correctness criterion in databases. Similarly, using the notion of conflicts, a correctness criterion, conflict-opacity (co-opacity) which is a sub-class of can be designed whose membership can be verified in polynomial time. Using the verification mechanism, an efficient STM implementation can be designed that is permissive w.r.t co-opacity. By storing multiple versions for each transaction object, multi-version STMs provide more concurrency than single-version STMs. But the main drawback of co-opacity is that it does not admit histories that are uses multiple versions. This has motivated us to develop a new conflict notions for multi-version STMs. In this paper, we present a new conflict notion multi-version conflict. Using this conflict notion, we identify a new subclass of opacity (a popular correctness-criterion), mvc-opacity that admits multi-versioned histories and whose membership can be verified in polynomial time. We show that co-opacity is a proper subset of this class. The proposed conflict notion mv-conflict can be applied on non-sequential histories as well unlike traditional conflicts. Further, we believe that this conflict notion can be easily extended to other correctness-criterion as well.

cs.DC↗
arXiv2013

Non-Interference and Local Correctness in Transactional Memory

Transactional memory promises to make concurrent programming tractable and efficient by allowing the user to assemble sequences of actions in atomic transactions with all-or-nothing semantics. It is believed that, by its very virtue, transactional memory must ensure that all committed transactions constitute a serial execution respecting the real-time order. In contrast, aborted or incomplete transactions should not "take effect." But what does "not taking effect" mean exactly? It seems natural to expect that aborted or incomplete transactions do not appear in the global serial execution, and, thus, no committed transaction can be affected by them. We investigate another, less obvious, feature of "not taking effect" called non-interference: aborted or incomplete transactions should not force any other transaction to abort. In the strongest form of non-interference that we explore in this paper, by removing a subset of aborted or incomplete transactions from the history, we should not be able to turn an aborted transaction into a committed one without violating the correctness criterion. We show that non-interference is, in a strict sense, not implementable with respect to the popular criterion of opacity that requires all transactions (be they committed, aborted or incomplete) to witness the same global serial execution. In contrast, when we only require local correctness, non-interference is implementable. Informally, a correctness criterion is local if it only requires that every transaction can be serialized along with (a subset of) the transactions committed before its last event (aborted or incomplete transactions ignored). We give a few examples of local correctness properties, including the recently proposed criterion of virtual world consistency, and present a simple though efficient implementation that satisfies non-interference and local opacity.

cs.DC↗
arXiv2013

A TimeStamp based Multi-version STM Protocol that satisfies Opacity and Multi-Version Permissiveness

Software Transactional Memory Systems (STM) are a promising alternative to lock based systems for concurrency control in shared memory systems. In multiversion STM systems, each write on a transaction object produces a new version of that object. The advantage obtained by storing multiple versions is that one can ensure that read operations do not fail. Opacity is a commonly used correctness criterion for STM systems. Multi-Version permissive STM system never aborts a read-only transaction. Although many multi-version STM systems have been proposed, to the best of our knowledge none of them have been formally proved to satisfy opacity. In this paper we present a time-stamp based multiversion STM system that satisfies opacity and mv-permissiveness. We formally prove the correctness of the proposed STM system. We also present garbage collection procedure which deletes unwanted versions of the transaction objects and formally prove it correctness.

cs.DC↗