Distributing Context-Aware Shared Memory Data Structures: A Case Study on Singly-Linked Lists

TL;DR

This work tackles distributing a context-aware shared-memory data structure by partitioning a lock-free singly-linked list across multiple servers while preserving client-visible operation guarantees. It introduces two distribution protocols, Aborting Move (AM) and Temporary Replication (TR), which rely on minimal primitives (CAS and RDCSS) and a sublist Registry to manage ownership and movement. AM prioritizes client operations and aborts moves when concurrent updates occur, while TR allows client-visible updates to be replayed and replicated to ensure progress without latency penalties. Together, these protocols enable scalable, lock-free, context-aware distributed lists and offer a pathway to extend the approach to other data structures like sorted lists and dictionaries, with potential for crash-tolerant and replicated variants.

Abstract

In this paper, we study the partitioning of a context-aware shared memory data structure so that it can be implemented as a distributed data structure running on multiple machines. By context-aware data structures, we mean that the result of an operation not only depends upon the value of the shared data but also upon the previous operations performed by the same client. While there is substantial work on designing distributed data structures, designing distributed context-aware data structures has not received much attention. We focus on singly-linked lists as a case study of the context-aware data structure. We start with a shared memory context-aware lock-free singly-linked list and show how it can be transformed into a distributed lock-free context-aware singly-linked list. The main challenge in such a transformation is to preserve properties of client-visible operations of the underlying data structure. We present two protocols that preserve these properties of client-visible operations of the linked list. In the first protocol, the distribution is done in the background as a low priority task, while in the second protocol the client-visible operations help the task of distribution without affecting client latency. In both protocols, the client-visible operations remain lock-free. Also, our transformation approach does not utilize any hardware primitives (except a compare-and-swap operation on a single word). We note that our transformation is generic and can be used for other lock-free context-aware data structures that can be constructed from singly-linked lists.

Figures (4)

• Figure 1: A sample list
• Figure 2: ${\tt Lookup}\xspace$ (blue) for items from all active servers and ${\tt{InsertAfter}}\xspace$ (red) requested at the server that owns the item.
• Figure 3: A list being composed of a set of 4 sublists.
• Figure 4: Splitting of a sublist inserts a block containing two nodes(ST and SH) at the chosen point of Split (C)

Theorems & Definitions (29)

• Lemma C.1
• proof
• Definition C.1: Termination Condition
• Lemma C.2
• proof
• Theorem C.3
• proof
• Lemma D.1
• proof
• Definition D.1: Successor and Predecessor