Concurrent Access Algorithms for Different Data Structures: A Research Review

Algorithms for concurrent data structure have gained attention in recent years as multi-core processors have become ubiquitous. Several features of shared-memory multiprocessors make concurrent data structures significantly more difficult to design and to verify as correct than their sequential counterparts. The primary source of this additional difficulty is concurrency. This paper provides an overview of the some concurrent access algorithms for different data structures

Adaptive Lock-Free Data Structures in Haskell: A General Method for Concurrent Implementation Swapping

A key part of implementing high-level languages is providing built-in and default data structures. Yet selecting good defaults is hard. A mutable data structure's workload is not known in advance, and it may shift over its lifetime - e.g., between read-heavy and write-heavy, or from heavy contention by multiple threads to single-threaded or low-frequency use. One idea is to switch implementations adaptively, but it is nontrivial to switch the implementation of a concurrent data structure at runtime. Performing the transition requires a concurrent snapshot of data structure contents, which normally demands special engineering in the data structure's design. However, in this paper we identify and formalize an relevant property of lock-free algorithms. Namely, lock-freedom is sufficient to guarantee that freezing memory locations in an arbitrary order will result in a valid snapshot. Several functional languages have data structures that freeze and thaw, transitioning between mutable and immutable, such as Haskell vectors and Clojure transients, but these enable only single-threaded writers. We generalize this approach to augment an arbitrary lock-free data structure with the ability to gradually freeze and optionally transition to a new representation. This augmentation doesn't require changing the algorithm or code for the data structure, only replacing its datatype for mutable references with a freezable variant. In this paper, we present an algorithm for lifting plain to adaptive data and prove that the resulting hybrid data structure is itself lock-free, linearizable, and simulates the original. We also perform an empirical case study in the context of heating up and cooling down concurrent maps.Comment: To be published in ACM SIGPLAN Haskell Symposium 201

Concurrency in Blockchain Based Smartpool with Transactional Memory

Blockchain is the buzzword in today\u27s modern technological world. It is an undeniably ingenious invention of the 21st century. Blockchain was first coined and used by a cryptocurrency namedBitcoin. Since then bitcoin and blockchain are so popular that every single person is taking on bitcoin these days and the price of bitcoin has leaped to a staggering price in the last year and so.Today several other cryptocurrencies have adapted the blockchain technology. Blockchain in cryptocurrencies is formed by chaining of blocks. These blocks are created by the nodes called miners through the process called Proof of Work(PoW). Mining Pools are formed as a collection of miners which collectively tries to solve a puzzle. However, most of the mining pools are centralized. P2Pool is the first decentralized mining pool in Bitcoin but is not that popular as the number of messages exchanged among the miners is a scalar multiple of the number of shares. SmartPool is a decentralized mining pool with the throughput equal to that of the traditional pool. However, the verification of blocks is done in a sequential manner. We propose a non-blocking concurrency mechanism in a decentralized mining pool for the verification of blocks in a blockchain. Smart contract in SmartPool is concurrently executed using a transactional memory approach without the use of locks. Since the SmartPool mining implemented in ethereum can be applied to Bitcoin, this concurrency method proposed in ethereum smart contracts can be applicable in Bitcoin as well