Searcharxiv⌕ Search

arXiv subjects

Sathya Peri

Publications and source records attributed to Sathya Peri.

At least 19 recordsLinked to original sources
arXiv2026

Domain Extension of Lock-Freedom and Wait-Freedom for Group Computations

A domain extension of a definition refers to broadening the scope of a definition so that it applies to a larger set of cases than originally specified. The notion of lock-free and wait-free computation is designed for the domain of tasks that are completed by a single thread (in competition with other threads). The goal of this paper is to extend the definition of lock-freedom and wait-freedom to group-computations (denoted by gl-freedom and gw-freedom) that require that the task at hand must be completed by a collaboration between multiple threads. When extending a definition, certain constraints must be respected: the new domain must remain logically consistent with the original meaning, the extension should not introduce contradictions or ambiguities, and it must preserve the essential properties that make the definition valid and useful. We demonstrate this by showing that our extended definition is consistent with the original definition when the group consists of a single thread. We note that extension allows us to characterize programs in a new domain (distributed computing, NUMA computation systems, systems with private data for different threads, etc.) instead of relegating them to be in the same category (deadlock/livelock-free) without regard to the actual properties of that program. We also illustrate this definition with various examples.

cs.DC↗
arXiv2026

BlockRaFT: A Distributed Framework for Fault-Tolerant and Scalable Blockchain Nodes

Blockchain technology enhances transparency by maintaining a distributed ledger among mutually untrusting parties. Despite its advantages, scalability and availability remain critical bottlenecks that hinder widespread adoption. The increasing complexity of blockchain nodes further necessitates robust fault tolerance and high throughput to ensure seamless operations. We present BlockRaFT, a crash-tolerant distributed framework designed to improve both the scalability and reliability of blockchain node operations. BlockRaFT framework utilizes RAFT consensus protocol to elect a leader within a cluster of systems. The elected leader coordinates and distributes workloads across follower nodes, thereby optimizing resource utilization and work load balancing. We analyzed the tasks performed by blockchain nodes and partition them according to their stateful and stateless characteristics. Stateless operations are centralized at the leader, while stateful operations are replicated and coordinated across the cluster to ensure consistency and fault tolerance. We evaluate whether this distributed intra-node architecture provides measurable benefits over traditional single-node execution models in terms of scalability, availability, and performance. Additionally, we introduce a concurrent Merkle tree optimization that decouples smart contract execution from tree updates, significantly reducing one of the significant performance overheads in blockchain systems. Our design philosophy is rooted in utilizing the well-established principles of distributed computing and customizing them for the blockchain domain rather than reinventing them.

cs.DC↗
arXiv2025

Lock-free Asynchronously Distributed Linked Lists

Modern databases use dynamic search structures that store an enormous amount of data, and often serve them using multi-threaded algorithms to support the ever-increasing throughput needs. When this throughput need exceeds the capacity of the machine hosting the structure, one either needs to replace the underlying hardware (an option that is typically not viable and introduces a long down time) or make the data structure distributed. Static partitioning of the data structure for distribution is not desirable, as it is prone to uneven load distribution over time, and having to change the partitioning scheme later will require downtime. The goal of this paper is to extend a concurrent data structure to distributed data structures that provide dynamic load balancing while preserving important properties such as lock freedom. With this intuition, first, we introduce the notion of conditional lock-freedom which extends the notion of lock-free computation with reasonable assumptions about communication between processes. Then, we present DiLi, a conditional lock-free, linearizable, and distributed linked list that can be asynchronously and dynamically (1) partitioned into multiple sublists and (2) load balanced by distributing sublists across multiple machines. DiLi contains primitives for these that also maintain the lock-free property of the underlying search structure that supports find, remove, and insert of a key as the client operations. We show that DiLi bridges the gap between concurrent data structures and distributed data structures. Specifically, DiLi provides comparable (and better in write-intensive workloads) performance to skip lists (which are typically the fastest data structures for search in a concurrent environment). In addition, it provides horizontal scaling with dynamic load balancing in a distributed environment.

cs.DC↗
arXiv2025

Dependency-Aware Execution Mechanism in Hyperledger Fabric Architecture

Hyperledger Fabric is a leading permissioned blockchain framework for enterprise use, known for its modular design and privacy features. While it strongly supports configurable consensus and access control, Fabric can face challenges in achieving high transaction throughput and low rejection rates under heavy workloads. These performance limitations are often attributed to endorsement, ordering, and validation bottlenecks. Further, optimistic concurrency control and deferred validation in Fabric may lead to resource inefficiencies and contention, as conflicting transactions are identified only during the commit phase. To address these challenges, we propose a dependency-aware execution model for Hyperledger Fabric. Our approach includes: (a) a dependency flagging system during endorsement, marking transactions as independent or dependent using a hashmap; (b) an optimized block construction in the ordering service that prioritizes independent transactions; (c) the incorporation of a Directed Acyclic Graph (DAG) within each block to represent dependencies; and (d) parallel execution of independent transactions at the committer, with dependent transactions processed according to DAG order. Incorporated in Hyperledger Fabric v2.5, our framework was tested on workloads with varying dependency levels and system loads. Results show up to 40% higher throughput and significantly reduced rejection rates in high-contention scenarios. This demonstrates that dependency-aware scheduling and DAG-based execution can substantially enhance Fabric's scalability while remaining compatible with its existing consensus and smart contract layers.

cs.DC↗
arXiv2025

Fault-Tolerant Decentralized Distributed Asynchronous Federated Learning with Adaptive Termination Detection

Federated Learning (FL) facilitates collaborative model training across distributed clients while ensuring data privacy. Traditionally, FL relies on a centralized server to coordinate learning, which creates bottlenecks and a single point of failure. Decentralized FL architectures eliminate the need for a central server and can operate in either synchronous or asynchronous modes. Synchronous FL requires all clients to compute updates and wait for one another before aggregation, guaranteeing consistency but often suffering from delays due to slower participants. Asynchronous FL addresses this by allowing clients to update independently, offering better scalability and responsiveness in heterogeneous environments. Our research develops an asynchronous decentralized FL approach in two progressive phases. (a) In Phase 1, we develop an asynchronous FL framework that enables clients to learn and update independently, removing the need for strict synchronization. (b) In Phase 2, we extend this framework with fault tolerance mechanisms to handle client failures and message drops, ensuring robust performance even under unpredictable conditions. As a central contribution, we propose Client-Confident Convergence and Client-Responsive Termination novel techniques that provide each client with the ability to autonomously determine appropriate termination points. These methods ensure that all active clients conclude meaningfully and efficiently, maintaining reliable convergence despite the challenges of asynchronous communication and faults.

cs.DC↗
arXiv2025

Efficient Task Graph Scheduling for Parallel QR Factorization in SLSQP

Efficient task scheduling is paramount in parallel programming on multi-core architectures, where tasks are fundamental computational units. QR factorization is a critical sub-routine in Sequential Least Squares Quadratic Programming (SLSQP) for solving non-linear programming (NLP) problems. QR factorization decomposes a matrix into an orthogonal matrix Q and an upper triangular matrix R, which are essential for solving systems of linear equations arising from optimization problems. SLSQP uses an in-place version of QR factorization, which requires storing intermediate results for the next steps of the algorithm. Although DAG-based approaches for QR factorization are prevalent in the literature, they often lack control over the intermediate kernel results, providing only the final output matrices Q and R. This limitation is particularly challenging in SLSQP, where intermediate results of QR factorization are crucial for back-substitution logic at each iteration. Our work introduces novel scheduling techniques using a two-queue approach to execute the QR factorization kernel effectively. This approach, implemented in high-level C++ programming language, facilitates compiler optimizations and allows storing intermediate results required by back-substitution logic. Empirical evaluations demonstrate substantial performance gains, including a 10x improvement over the sequential QR version of the SLSQP algorithm.

cs.DC↗
arXiv2024

Unleashing Multicore Strength for Efficient Execution of Transactions

Blockchain technology is booming up the digital world in recent days and thus paved a way for creating separate blockchain network for various industries. This technology is characterized by its distributed, decentralized, and immutable ledger system which serves as a fundamental platform for managing smart contract transactions (SCTs). However, these self-executing codes implemented using blockchains undergo sequential validation within a block which introduces performance bottlenecks. In response, this paper introduces a framework called the Multi-Bin Parallel Scheduler (MBPS) designed for parallelizing blockchain smart contract transactions to leverage the capabilities of multicore systems. Our proposed framework facilitates concurrent execution of SCTs, enhancing performance by allowing non-conflicting transactions to be processed simultaneously while preserving deterministic order. The framework comprises of three vital stages: conflict detection, bin creation and execution. We conducted an evaluation of our MBPS framework in Hyperledger Sawtooth v1.2.6, revealing substantial performance enhancements compared to existing parallel SCT execution frameworks across various smart contract applications. This research contributes to the ongoing optimization efforts in blockchain technology demonstrating its potential for scalability and efficiency in real-world scenarios.

cs.DC↗
arXiv2024

Construction of a Byzantine Linearizable SWMR Atomic Register from SWSR Atomic Registers

The SWMR atomic register is a fundamental building block in shared memory distributed systems and implementing it from SWSR atomic registers is an important problem. While this problem has been solved in crash-prone systems, it has received less attention in Byzantine systems. Recently, Hu and Toueg gave such an implementation of the SWMR register from SWSR registers. While their definition of register linearizability is consistent with the definition of Byzantine linearizability of a concurrent history of Cohen and Keidar, it has these drawbacks. (1) If the writer is Byzantine, the register is linearizable no matter what values the correct readers return. (2) It ignores values written consistently by a Byzantine writer. We need a stronger notion of a {\em correct write operation}. (3) It allows a value written to just one or a few readers' SWSR registers to be returned, thereby not validating the intention of the writer to write that value honestly. (4) Its notion of a ``current'' value returned by a correct reader is not related to the most recent value written by a correct write operation of a Byzantine writer. We need a more up to date version of the value that can be returned by a correct reader. In this paper, we give a stronger definition of a Byzantine linearizable register that overcomes the above drawbacks. Then we give a construction of a Byzantine linearizable SWMR atomic register from SWSR registers that meets our stronger definition. The construction is correct when $n>3f$, where $n$ is the number of readers, $f$ is the maximum number of Byzantine readers, and the writer can also be Byzantine. The construction relies on a public-key infrastructure.

cs.DC↗
arXiv2024

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

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.

cs.DC↗
arXiv2023

Non-blocking Dynamic Unbounded Graphs with Wait-Free Snapshot

Graphs are arguably one of the most fundamental data-structure used in many domains such as block-chain, networks etc. Theoretically and practically, improving Graph performance is one of the most studied and omnipresent research problems. In this paper, we have implemented a dynamic unbounded concurrent graph which can perform the add, delete or lookup operations on vertices and edges concurrently. All these methods are lock-free and linearizable. On top of this, we have also implemented the wait-free graph snapshot algorithm. To the best of knowledge this is first wait-free implementation of snapshot on concurrent graphs. We have used the snapshot of the algorithm to calculate the diameter and between centrality. We have compared our implementation with its counterparts and outperformed them by a good margin. This illustrates the efficiency of our snapshot method which is a generic method and can be used to perform other useful graph analytics operations.

cs.DC↗
arXiv2023

Learned Lock-free Search Data Structures

Non-blocking search data structures offer scalability with a progress guarantee on high-performance multi-core architectures. In the recent past, "learned queries" have gained remarkable attention. It refers to predicting the rank of a key computed by machine learning models trained to infer the cumulative distribution function of an ordered dataset. A line of works exhibits the superiority of learned queries over classical query algorithms. Yet, to our knowledge, no existing non-blocking search data structure employs them. In this paper, we introduce \textbf{Kanva}, a framework for learned non-blocking search. Kanva has an intuitive yet non-trivial design: traverse down a shallow hierarchy of lightweight linear models to reach the "non-blocking bins," which are dynamic ordered search structures. The proposed approach significantly outperforms the current state-of-the-art -- non-blocking interpolation search trees and elimination (a,b) trees -- in many workload and data distributions. Kanva is provably linearizable.

cs.DC↗
arXiv2023

Wait-Free Updates and Range Search using Uruv

CRUD operations, along with range queries make a highly useful abstract data type (ADT), employed by many dynamic analytics tasks. Despite its wide applications, to our knowledge, no fully wait-free data structure is known to support this ADT. In this paper, we introduce Uruv, a proactive linearizable and practical wait-free concurrent data structure that implements the ADT mentioned above. Structurally, Uruv installs a balanced search index on the nodes of a linked list. Uruv is the first wait-free and proactive solution for concurrent B+tree. Experiments show that Uruv significantly outperforms previously proposed lock-free B+trees for dictionary operations and a recently proposed lock-free method to implement the ADT mentioned above.

cs.DC↗
arXiv2023

An Efficient Framework for Execution of Smart Contracts in Hyperledger Sawtooth

Blockchain technology is a distributed, decentralized, and immutable ledger system. It is the platform of choice for managing smart contract transactions (SCTs). Smart contracts are self-executing codes of agreement between interested parties commonly implemented using blockchains. A block contains a set of transactions representing changes to the system and a hash of the previous block. The SCTs are executed multiple times during the block production and validation phases across the network. The execution is sequential in most blockchain technologies. In this work, we incorporate a direct acyclic graph (DAG) based parallel scheduler framework for concurrent execution of SCTs. The dependencies among a block's transactions are represented through a concurrent DAG data structure that assists in throughput optimization. We have created a DAG scheduler module that can be incorporated into blockchain platforms for concurrent execution with ease. We have also formally established the safety and liveness properties of the DAG scheduler. For evaluation, our framework is implemented in Hyperledger Sawtooth V1.2.6. The performance across multiple smart contract applications is measured for various scheduler types. Experimental analysis shows that the proposed framework achieves notable performance improvements over the parallel SCT execution frameworks.

cs.DC↗
arXiv2022

An Efficient Approach to Move Elements in a Distributed Geo-Replicated Tree

Replicated tree data structures are extensively used in collaborative applications and distributed file systems, where clients often perform move operations. Local move operations at different replicas may be safe. However, remote move operations may not be safe. When clients perform arbitrary move operations concurrently on different replicas, it could result in various bugs, making this operation challenging to implement. Previous work has revealed bugs such as data duplication and cycling in replicated trees. In this paper, we present an efficient algorithm to perform move operations on the distributed replicated tree while ensuring eventual consistency. The proposed technique is primarily concerned with resolving conflicts efficiently, requires no interaction between replicas, and works well with network partitions. We use the last write win semantics for conflict resolution based on globally unique timestamps of operations. The proposed solution requires only one compensation operation to avoid cycles being formed when move operations are applied. The proposed approach achieves an effective speedup of 68.19$\times$ over the state-of-the-art approach in a geo-replicated setting on Microsoft Azure standard instances at three different continents.

cs.DC↗
arXiv2022

FUSED-PAGERANK: Loop-Fusion based Approximate PageRank

PageRank is a graph centrality metric that gives the importance of each node in a given graph. The PageRank algorithm provides important insights to understand the behavior of nodes through the connections they form with other nodes. It is an iterative algorithm that ranks the nodes in each iteration until all the node values converge. The PageRank algorithm is implemented using sparse storage format, which results in irregular memory accesses in the code. This key feature inhibits optimizations to improve its performance, and makes optimizing the PageRank algorithm a non-trivial problem. In this work we improve the performance of PageRank algorithm by reducing its irregular memory accesses. In this paper, we propose FUSED-PAGERANK algorithm, a compiler optimization oriented approximate technique that reduces the number of irregular memory accesses in the PageRank algorithm, improving its locality while making the convergence of the algorithm faster with better accuracy in results. In particular, we propose an approximate PageRank algorithm using Loop-Fusion. We believe that ours is the first work that formally applies traditional compiler optimization techniques for irregular memory access in the PageRank algorithm. We have verified our method by performing experiments on a variety of datasets: LAW graphs, SNAP datasets and synthesized datasets. On these benchmarks, we have achieved a maximum speedup (vs. -O3 optimization) of 2.05X, 2.23X, 1.74X with sequential version, and ~4.4X, ~2.61X, ~4.22X with parallel version of FUSED-PAGERANK algorithm in comparison with Edge-centric version of PageRank algorithm.

cs.DS↗
arXiv2021

An Improved and Optimized Practical Non-Blocking PageRank Algorithm for Massive Graphs

PageRank is a well-known algorithm whose robustness helps set a standard benchmark when processing graphs and analytical problems. The PageRank algorithm serves as a standard for many graph analytics and a foundation for extracting graph features and predicting user ratings in recommendation systems. The PageRank algorithm iterates continuously, updating the ranks of the pages till convergence is achieved. Nevertheless, the implementation of the PageRank algorithm on large-scale graphs that on shared memory architecture utilizing fine-grained parallelism is a difficult task at hand. The experimental study and analysis of the Parallel PageRank kernel on large graphs and shared memory architectures using different programming models have been studied extensively. This paper presents the asynchronous execution of the PageRank algorithm to leverage the computations on massive graphs, especially on shared memory architectures. We evaluate the performance of our proposed non-blocking algorithms for PageRank computation on real-world and synthetic datasets using Posix Multithreaded Library on a 56 core Intel(R) Xeon processor. We observed that our asynchronous implementations achieve 10x to 30x speedup with respect to sequential runs and 5x to 10x improvements over synchronous variants.

cs.DC↗
arXiv2021

DiPETrans: A Framework for Distributed Parallel Execution of Transactions of Blocks in Blockchain

Contemporary blockchain such as Bitcoin and Ethereum execute transactions serially by miners and validators and determine the Proof-of-Work (PoW). Such serial execution is unable to exploit modern multi-core resources efficiently, hence limiting the system throughput and increasing the transaction acceptance latency. The objective of this work is to increase the transaction throughput by introducing parallel transaction execution using a static analysis technique. We propose a framework DiPETrans for the distributed execution of the transactions in a block. Here, peers in the blockchain network form a community to execute the transactions and find the PoW parallelly, using a leader-follower approach. During mining, the leader statically analyzes the transactions, creates different groups (shards) of independent transactions, and distributes them to followers to execute them in parallel. After the transaction executes, the community's compute power is utilized to solve the PoW concurrently. When a block is successfully created, the leader broadcasts the proposed block to other peers in the network for validation. On receiving a block, validators re-execute the block transactions and accept the block if they reach the same state as shared by the miner. Validation can also be done as a community, in parallel, following the same leader-follower approach as mining. We report experiments using over 5 Million real transactions from the Ethereum blockchain and execute them using our DiPETrans framework to empirically validate the benefits of our techniques over traditional sequential execution. We achieve a maximum speedup of 2.2x for the miner and 2.0x for the validator, with 100 to 500 transactions per block. Further, we achieve a peak of 5x end-to-end block creation speedup using a parallel miner over a serial miner when using 6 machines in the community.

cs.DC↗