Search

The Industrial Internet of Things (IIoT) plays an important role in the development of smart factories. However, the existing IIoT systems are prone to suffering from single points of failure and unable to provide stable service. Meanwhile, with the increase of node scale and network quantity, the maintenance cost presents to be higher. Such a disadvantage can be effectively compensated by the features such as security, privacy, non-tamperability and distributed deployment supported by the blockchain. In this paper, first, an intelligent manufacturing security model based on blockchain was proposed. Due to the high power consumption and low throughput of the traditional blockchain, IoT devices with limited power consumption can not work independently. Therefore, in this paper, a new Merkle Patricia tree (MPT) was adopted to extend the blockchain structure and provide fast query of node status. Second, since the MPT does not support concurrent operation and the data operation performance deteriorates with high data volume, a lock-free concurrent and cache-based Merkle Patricia tree was proposed (CMPT) to support lock-free concurrent data operation, which can improve the data operation efficiency in multi-core system. The experimental results indicate that, compared with the original MPT, the CMPT proposed in this paper effectively reduced the time complexity of data insertion and data query and improved the speed of block construction and data query.

• The included proof is generic and presents a useful contour for proving correctness – linearizability and lock-freedom – of similar data structures. • A lock-free Approximate Nearest Neighbour Search algorithm is presented. • The lock-free algorithms are thoroughly evaluated to benchmark their comparative experimental performance. The Nearest neighbour search (NNS) is a fundamental problem in many application domains dealing with multidimensional data. In a concurrent setting, where dynamic modifications are allowed, a linearizable implementation of the NNS is highly desirable. This paper introduces the LockFree-kD-tree (LFkD-tree): a lock-free concurrent kD-tree, which implements an abstract data type (ADT) that provides the operations Add, Remove, Contains, and NNS. Our implementation is linearizable. The operations in the LFkD-tree use single-word read and compare-and-swap (▪) atomic primitives, which are readily supported on available multi-core processors. We experimentally evaluate the LFkD-tree using several benchmarks comprising real-world and synthetic datasets. The experiments show that the presented design is scalable and achieves significant speed-up compared to the implementations of an existing sequential kD-tree and a recently proposed multidimensional indexing structure, PH-tree. [ABSTRACT FROM AUTHOR]

This paper presents a non-blocking Patricia trie implementation for an asynchronous shared-memory system using Compare&Swap. The trie is a linearizable implementation of a set and supports three update operations: insert adds an element to the trie, delete removes an element from the trie and replace replaces one element by another. The replace operation is interesting because it changes two different locations of a trie. We design a mechanism that allows the two changes of a replace operation to appear to be executed atomically. If all update operations modify different parts of the trie, they run completely concurrently. The implementation also supports a wait-free find operation, which only reads shared memory and never changes the data structure. Our implementation and its correctness proof are modular and can be adapted for other data structures. Empirically, we compare our algorithms to some existing tree-based set implementations and our results show that our trie performs consistently well in different scenarios. [ABSTRACT FROM AUTHOR]

This paper focuses on a large class of concurrent data structures that we call pool-like objects (e.g., stack, double-ended queue, and queue). Performance and progress guarantee are two important characteristics for concurrent data structures. In the aspect of performance, weakening the internal order in a pool-like object is an effective technique to reduce the synchronization cost among threads accessing the object, but no objects with weakened internal order provide a progress guarantee as strong as wait-freedom. Meanwhile, wait-free algorithms tend to be inefficient, which is mainly attributed to the helping mechanisms. Based on the philosophy of existing helping mechanisms, a wait-free pool-like object with weakened internal order would suffer from unnecessary process of getting the latest object state and synchronization. This paper takes a state-of-the-art implementation of stacks with weakened internal order as an example, and transforms it into a highly-efficient wait-free stack named WF-TS-Stack. The transformation method includes a helping mechanism with state reuse and a relaxed removal scheme. In addition, we use a simple and effective scheme to further improve the performance of WF-TS-Stack in Non-Uniform Memory Access (NUMA) architectures. Our evaluation with representative benchmarks shows that WF-TS-Stack outperforms its original building blocks by up to 1.45× at maximum concurrency. We also discuss how to yield an efficient double-ended queue (deque) variant of WF-TS-Stack, because deque is a more generalized pool-like object. [ABSTRACT FROM AUTHOR]

The recent years have seen increasingly widespread use of highly concurrent data structures in both multi-core and distributed computing environments, thereby escalating the priority for verifying their correctness. Quasi linearizability is a quantitative variation of the standard linearizability correctness condition to allow more implementation freedom for performance optimization. However, ensuring that the implementation satisfies the quantitative aspect of this new correctness condition is often an arduous task. In this paper, we propose the first automated method for formally verifying quasi linearizability of the implementation model of a concurrent data structure with respect to its sequential specification. The method is based on checking a relaxed version of the refinement relation between the implementation model and the specification model through explicit state model checking. Our method can directly handle concurrent systems where each thread or process makes infinitely many method calls. Furthermore, unlike many existing verification methods, it does not require the user to supply annotations of the linearization points. We have implemented the new method in the PAT verification framework. Our experimental evaluation shows that the method is effective in verifying the new quasi linearizability requirement and detecting violations. [ABSTRACT FROM AUTHOR]

The throughput of concurrent priority queues is pivotal to multiprocessor applications such as discrete event simulation, best-first search and task scheduling. Existing lock-free priority queues are mostly based on skiplists, which probabilistically create shortcuts in an ordered list for fast insertion of elements. The use of skiplists eliminates the need of global rebalancing in balanced search trees and ensures logarithmic sequential search time on average, but the worst-case performance is linear with respect to the input size. In this paper, we propose a quiescently consistent lock-free priority queue based on a multi-dimensional list that guarantees worst-case search time of \mathcal O(\log N) for key universe of size $N$ . The novel multi-dimensional list (MDList) is composed of nodes that contain multiple links to child nodes arranged by their dimensionality. The insertion operation works by first injectively mapping the scalar key to a high-dimensional vector, then uniquely locating the target position by using the vector as coordinates. Nodes in MDList are ordered by their coordinate prefixes and the ordering property of the data structure is readily maintained during insertion without rebalancing nor randomization. In our experimental evaluation using a micro-benchmark, our priority queue achieves an average of $50$ percent speedup over the state of the art approaches under high concurrency. [ABSTRACT FROM PUBLISHER]

Abstract: With the proliferation of multiprocessor computers, data structures capable of supporting several processes are a growing need. Concurrent data structures seek to provide similar performance to sequential data structures while being accessible concurrently by several processes and providing synchronization mechanisms transparently to those processes. Red–black trees are an important data structure used in many systems. Unfortunately, it is difficult to implement an efficient concurrent red–black tree for shared memory processes; so most research efforts have been directed towards other dictionary data structures, mainly skip-lists and AVL trees. In this paper we present a new type of concurrent red–black tree that uses optimistic concurrency techniques and new balancing operations to scale well and support contention. Our tree performs favorably compared to other similar dictionaries; in particular, in high contention scenarios it performs up to 14% better than the best-known concurrent dictionary solutions. [Copyright &y& Elsevier]

We examine the design, implementation, and experimental analysis of parallel priority queues for device and network simulation. We consider: 1) distributed splay trees using MPI, 2) concurrent heaps using shared memory atomic locks, and 3) a new, more general concurrent data structure based on distributed sorted lists, which is designed to provide dynamically balanced work allocation (with automatic or manual control) and efficient use of shared memory resources. We evaluate performance for all three data structures on a Cray-T3E900 system at KFA-Jülich. Our comparisons are based on simulations of single buffers and a 64 x 64 packet switch which supports multicasting. In all implementations, PEs monitor traffic at their preassigned input/output ports, while priority queue elements are distributed across the Cray-T3E virtual shared memory. Our experiments with up to 60,000 packets and two to 64 PEs indicate that concurrent priority queues perform much better than distributed ones. Both concurrent implementations have comparable performance, while our new data structure uses less memory and has been further optimized. We also consider parallel simulation for symmetric networks by sorting integer conflict functions and implementing an interesting packet indexing scheme. The optimized message passing network simulator can process ∼ 500K packet moves in one second, with an efficiency that exceeds ∼ 50 percent for a few thousands packets on the Cray-T3E with 32 PEs. All developed data structures now form a parallel library. Although our concurrent implementations use the Cray-T3E ShMem library, portability can be derived from Open-MP or MPI-2 standard libraries, which will provide support for one-way communication and shared memory lock mechanisms.. [ABSTRACT FROM AUTHOR]

The Industrial Internet of Things (IIoT) plays an important role in the development of smart factories. However, the existing IIoT systems are prone to suffering from single points of failure and unable to provide stable service. Meanwhile, with the increase of node scale and network quantity, the maintenance cost presents to be higher. Such a disadvantage can be effectively compensated by the features such as security, privacy, non-tamperability and distributed deployment supported by the blockchain. In this paper, first, an intelligent manufacturing security model based on blockchain was proposed. Due to the high power consumption and low throughput of the traditional blockchain, IoT devices with limited power consumption can not work independently. Therefore, in this paper, a new Merkle Patricia tree (MPT) was adopted to extend the blockchain structure and provide fast query of node status. Second, since the MPT does not support concurrent operation and the data operation performance deteriorates with high data volume, a lock-free concurrent and cache-based Merkle Patricia tree was proposed (CMPT) to support lock-free concurrent data operation, which can improve the data operation efficiency in multi-core system. The experimental results indicate that, compared with the original MPT, the CMPT proposed in this paper effectively reduced the time complexity of data insertion and data query and improved the speed of block construction and data query.