Page not found. Your pixels are in another canvas. Read more
Sitemap
A list of all the posts and pages found on the site. For you robots out there is an XML version available for digesting as well.
Pages
Page not in menu
This is a page not in th emain menu Read more
Posts
Demystifying graph databases
Published:
The World of Graph Databases from An Industry Perspective
Published:
This paper by Yuanyuan Tian presents an overview of the graph database landscape from an industry perspective. It covers the graph database landscape, graph query languages and several graph database products. It also discusses the challenges and opportunities in the graph database industry. Read more
Dominance Locking in arbitrary rooted hierarchies
Published:
The current state of affairs in databases is typically oriented towards two-dimensional data. If some data is managed in an apparent multidimensional space, then it is usually achieved by some trick that involves joining tables and pivoting them. This not only makes performing queries on the data difficult and less efficient but also introduces an overhead of managing these multidimensional views. Read more
DomLock: a new multi-granularity locking technique for hierarchies
Published:
In the paper “DomLock: a new multi-granularity locking technique for hierarchies” the authors present an interesting technique for locking objects that follow a hierarchical structure. Several applications that operate on objects that form a hierarchy suffer from synchronization bottlenecks because of lock contention. When several transactions operate on different parts of the data hierarchy, there is contention which restricts concurrency. Read more
Transactional Boosting: A Methodology for Highly-Concurrent Transactional Objects
Published:
Software transactional memory (STM) is an emergent alternative to mutual exclusion. In STM, the activities are organised as transactions which can commit or abort. Most transactional memory systems synchronise on the basis of read/write conflicts. Two transactions are said to be in conflict if they modify at-least one same object. When conflicting transactions need to commit, we need some mechanism to resolve this conflict. This can be done by forcing either transaction to abort. The benefit of this type of conflict detection and resolution is that the overhead of managing conflicts does not fall to the programmer. But at the same time, this method also severely restricts the concurrency for shared objects which come under contention very often. Read more
Lock Coarsening: Eliminating Lock Overhead in Automatically Parallelized Object-Based Programs
Published:
Atomic operations are a key primitive in parallel computing. Typically atomic ownership is provided via mutual exclusion which is achieved in the simplest way through locking. A lock is said to be finely grained if it exclusively locks only a small part of the data structure and thus suffers from low contention. The question still remains. What should we lock and how fine can the lock granularity be without sacrificing on performance? At what point does the cost of maintaining locks override the benefit achieved from the finer locking. Read more
Zeus: locality aware distributed transactions
Published:
Typical databases have distributed transactions that update multiple objects. These objects are updated by transactions that span multiple shards and require coordination for state reconciliation. Most popular protocol to reconcile the state is the two phase commit protocol. This distribution is an inherent problem since most transactions access multiple replicas and thus the communication latency between those replicas leads to a slowdown. The commit requiring coordination is also blocking. Zeus fetches the objects involved in a transaction’s operations locally and then performs the reads and writes on the local versions of the objects. Read more
Exploiting the commutativity lattice for parallelism
Published:
In the paper “Exploiting the commutativity lattice” the authors present a very interesting approach for managing parallel executions of transactions. They present systematic ways of reasoning about concurrency and how these ways can be implemented over different datastructures. Read more
publications
Persisting the AntidoteDB Cache: Design and Implementation of a Cache for a CRDT Datastore
Published in HAL-Inria, 2022
This report presents the design and implementation of a caching, indexing and object checkpoint library for AntidoteDB. Read more
Recommended citation: Ayush Pandey, Annette Bieniusa, Marc Shapiro. Persisting the AntidoteDB Cache: Design and Implementation of a Cache for a CRDT Datastore. [Research Report] RR-9470, TU Kaiserslautern; LIP6, Sorbonne Université. 2022. https://hal.inria.fr/hal-03654003/document
talks
Designing and Implementing a Persistent Cache for a CRDT Data store
Published:
This talk was given as a part of the workshop for RainbowFS. Read more
teaching
Datastructures
Undergraduate course, Sorbonne University, Computer Science, 2023
Synthetically present commonly used data structures used in computing in order to know the keys allowing one to choose optimally the most suitable structures to solve a given problem. Read more