An Efficient Wait-Free Vector

Feldman, Steven; Valera-Leon, Carlos; Dechev, Damian

doi:10.1109/TPDS.2015.2417887

Title: An Efficient Wait-Free Vector

Full Record
Other Related Research

Abstract

The vector is a fundamental data structure, which provides constant-time access to a dynamically-resizable range of elements. Currently, there exist no wait-free vectors. The only non-blocking version supports only a subset of the sequential vector API and exhibits significant synchronization overhead caused by supporting opposing operations. Since many applications operate in phases of execution, wherein each phase only a subset of operations are used, this overhead is unnecessary for the majority of the application. To address the limitations of the non-blocking version, we present a new design that is wait-free, supports more of the operations provided by the sequential vector, and provides alternative implementations of key operations. These alternatives allow the developer to balance the performance and functionality of the vector as requirements change throughout execution. Compared to the known non-blocking version and the concurrent vector found in Intel’s TBB library, our design outperforms or provides comparable performance in the majority of tested scenarios. Over all tested scenarios, the presented design performs an average of 4.97 times more operations per second than the non-blocking vector and 1.54 more than the TBB vector. In a scenario designed to simulate the filling of a vector, performance improvement increases to 13.38 and 1.16more »« less

Authors:

Feldman, Steven ^[1]; Valera-Leon, Carlos ^[1]; Dechev, Damian ^[2]

Univ. of Central Florida, Orlando, FL (United States)
Univ. of Central Florida, Orlando, FL (United States); Sandia National Lab. (SNL-CA), Livermore, CA (United States)

Publication Date:: Tue Mar 01 00:00:00 EST 2016

Research Org.:: Sandia National Lab. (SNL-NM), Albuquerque, NM (United States)

Sponsoring Org.:: USDOE National Nuclear Security Administration (NNSA)

OSTI Identifier:: 1427291

Report Number(s):: SAND-2015-2906J
Journal ID: ISSN 1045-9219; 583297

Grant/Contract Number:: AC04-94AL85000

Resource Type:: Accepted Manuscript

Journal Name:: IEEE Transactions on Parallel and Distributed Systems

Additional Journal Information:: Journal Volume: 27; Journal Issue: 3; Journal ID: ISSN 1045-9219

Publisher:: IEEE

Country of Publication:: United States

Language:: English

Subject:: 97 MATHEMATICS AND COMPUTING; vector; non-blocking; wait-free; concurrent; resizable; ABA

Citation Formats


                    Feldman, Steven, Valera-Leon, Carlos, and Dechev, Damian. An Efficient Wait-Free Vector.  United States: N. p., 2016. 
Web.  doi:10.1109/TPDS.2015.2417887.

Copy to clipboard


                    Feldman, Steven, Valera-Leon, Carlos, & Dechev, Damian. An Efficient Wait-Free Vector.  United States.  https://doi.org/10.1109/TPDS.2015.2417887

Copy to clipboard


                    Feldman, Steven, Valera-Leon, Carlos, and Dechev, Damian. Tue .  
"An Efficient Wait-Free Vector".  United States.  https://doi.org/10.1109/TPDS.2015.2417887.  https://www.osti.gov/servlets/purl/1427291.

Copy to clipboard


                    
@article{osti_1427291,

  title        = {An Efficient Wait-Free Vector},

  author       = {Feldman, Steven and Valera-Leon, Carlos and Dechev, Damian},

  abstractNote = {The vector is a fundamental data structure, which provides constant-time access to a dynamically-resizable range of elements. Currently, there exist no wait-free vectors. The only non-blocking version supports only a subset of the sequential vector API and exhibits significant synchronization overhead caused by supporting opposing operations. Since many applications operate in phases of execution, wherein each phase only a subset of operations are used, this overhead is unnecessary for the majority of the application. To address the limitations of the non-blocking version, we present a new design that is wait-free, supports more of the operations provided by the sequential vector, and provides alternative implementations of key operations. These alternatives allow the developer to balance the performance and functionality of the vector as requirements change throughout execution. Compared to the known non-blocking version and the concurrent vector found in Intel’s TBB library, our design outperforms or provides comparable performance in the majority of tested scenarios. Over all tested scenarios, the presented design performs an average of 4.97 times more operations per second than the non-blocking vector and 1.54 more than the TBB vector. In a scenario designed to simulate the filling of a vector, performance improvement increases to 13.38 and 1.16 times. This work presents the first ABA-free non-blocking vector. Finally, unlike the other non-blocking approach, all operations are wait-free and bounds-checked and elements are stored contiguously in memory.},

  doi          = {10.1109/TPDS.2015.2417887},

  journal      = {IEEE Transactions on Parallel and Distributed Systems},

  number       = 3,

  volume       = 27,

  place        = {United States},

  year         = {Tue Mar 01 00:00:00 EST 2016},

  month        = {Tue Mar 01 00:00:00 EST 2016}

}

Copy to clipboard

Journal Article:

Free Publicly Available Full Text

Accepted Manuscript (DOE)

Publisher's Version of Record

https://doi.org/10.1109/TPDS.2015.2417887

Other availability

Search WorldCat to find libraries that may hold this journal

Citation Metrics:

Cited by: 5 works

Citation information provided by
Web of Science

Save / Share:

Export Metadata

Save to My Library

Similar Records in DOE PAGES and OSTI.GOV collections:

Effective software design and development for the new graph architecture HPC machines.

Technical Report Dechev, Damian

Software applications need to change and adapt as modern architectures evolve. Nowadays advancement in chip design translates to increased parallelism. Exploiting such parallelism is a major challenge in modern software engineering. Multicore processors are about to introduce a significant change in the way we design and use fundamental data structures. In this work we describe the design and programming principles of a software library of highly concurrent scalable and nonblocking data containers. In this project we have created algorithms and data structures for handling fundamental computations in massively multithreaded contexts, and we have incorporated these into a usable library withmore »« less
https://doi.org/10.2172/1039407

Full Text Available
Research in wait-free synchronization. Final report, 1 Aug 88-31 Sep 91

Technical Report Wing, J M

The goal of the authors research is to develop systematic understanding of the theory and practice of highly concurrent data objects. Despite impressive progress in hardware that has made multiprocessors readily available for parallel processing, there is little agreement on the relative merits of competing architectures, and it has often proved difficult to realize these machines' potential for parallelism. Their research exploits the theory of abstract data types to derive: (1) impossibility results, showing that certain kinds of concurrency simply cannot be achieved with certain primitives; (2) new techniques for specifying and reasoning about the behavior of concurrent objects; andmore »« less
Are Lock-Free Concurrent Algorithms Practically Wait-Free?

Journal Article Alistarh, Dan ; Censor-Hillel, Keren ; Shavit, Nir - Journal of the Association for Computing Machinery

Lock-free concurrent algorithms guarantee that some concurrent operation will always make progress in a finite number of steps. Yet programmers prefer to treat concurrent code as if it were wait-free, guaranteeing that all operations always make progress. Unfortunately, designing wait-free algorithms is generally a very complex task, and the resulting algorithms are not always efficient. Although obtaining efficient wait-free algorithms has been a long-time goal for the theory community, most nonblocking commercial code is only lock-free. This article suggests a simple solution to this problem. We show that for a large class of lock-free algorithms, under scheduling conditions that approximatemore »« less
Cited by 3
https://doi.org/10.1145/2903136

Full Text Available
Data Locality Enhancement of Dynamic Simulations for Exascale Computing (Final Report)

Technical Report Shen, Xipeng

The development of modern processors exhibits two trends that complicate the optimizations of modern software. The first is the increasing sensitivity of processors' throughput to irregularities in computation. With more processors produced through a massive integration of simple cores, future systems will increasingly favor regular data-level parallel computations, but deviate from the needs of applications with complex patterns. Some evidences are already shown on Graphic Processing Units (GPU): Irregular data accesses (e.g., indirect references A[D[i]]) and conditional branches are limiting many GPU applications' performance at a level an order of magnitude lower than the peak of GPU. The second hardwaremore »« less
https://doi.org/10.2172/1576175

Full Text Available
Review of Enabling Technologies to Facilitate Secure Compute Customization

Technical Report Aderholdt, Ferrol ; Caldwell, Blake A ; Hicks, Susan Elaine ; ...

High performance computing environments are often used for a wide variety of workloads ranging from simulation, data transformation and analysis, and complex workflows to name just a few. These systems may process data for a variety of users, often requiring strong separation between job allocations. There are many challenges to establishing these secure enclaves within the shared infrastructure of high-performance computing (HPC) environments. The isolation mechanisms in the system software are the basic building blocks for enabling secure compute enclaves. There are a variety of approaches and the focus of this report is to review the different virtualization technologies thatmore »« less
https://doi.org/10.2172/1195817

Full Text Available

Similar Records