Process coordination with fetch-and-increment

Eric Freudenthal, Allan Gottlieb

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Abstract

The fetch-and-add (F&A) operation has been used effectively in a number of process coordination algorithms. In this paper we assess the power of fetch-and-increment (F&I) and fetch-and-decrement (F&D), which we view as restricted forms of F&A in which the only addends permitted are ±1. F&A-based algorithms that use only unit addends are thus trivially expressed with just F&I and F&D. Our primary contributions are new F&I/F&D algorithms for readers/writers coordination and barrier synchronization for dynamically-sized groups. We also restructure an existing F&A-based algorithm for queues-with-multiplicity to obtain an algorithm using just F&I and F&D. When executed on certain hardware architectures, most of these algorithms are free of serial bottlenecks. We also discuss a general technique for implementing F&A using F&I/F&D at a cost logarithmic in the number of processors.

Original languageEnglish (US)
Title of host publicationInternational Conference on Architectural Support for Programming Languages and Operating Systems - ASPLOS
Editors Anon
PublisherPubl by ACM
Pages260-268
Number of pages9
Volume26
Edition4
StatePublished - Apr 1991
Event4th International Conference on Architectural Support for Programming Languages and Operating Systems - Santa Clara, CA, USA
Duration: Apr 8 1991Apr 11 1991

Other

Other4th International Conference on Architectural Support for Programming Languages and Operating Systems
CitySanta Clara, CA, USA
Period4/8/914/11/91

Fingerprint

Synchronization
Hardware
Costs

ASJC Scopus subject areas

  • Hardware and Architecture

Cite this

Freudenthal, E., & Gottlieb, A. (1991). Process coordination with fetch-and-increment. In Anon (Ed.), International Conference on Architectural Support for Programming Languages and Operating Systems - ASPLOS (4 ed., Vol. 26, pp. 260-268). Publ by ACM.

Process coordination with fetch-and-increment. / Freudenthal, Eric; Gottlieb, Allan.

International Conference on Architectural Support for Programming Languages and Operating Systems - ASPLOS. ed. / Anon. Vol. 26 4. ed. Publ by ACM, 1991. p. 260-268.

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Freudenthal, E & Gottlieb, A 1991, Process coordination with fetch-and-increment. in Anon (ed.), International Conference on Architectural Support for Programming Languages and Operating Systems - ASPLOS. 4 edn, vol. 26, Publ by ACM, pp. 260-268, 4th International Conference on Architectural Support for Programming Languages and Operating Systems, Santa Clara, CA, USA, 4/8/91.
Freudenthal E, Gottlieb A. Process coordination with fetch-and-increment. In Anon, editor, International Conference on Architectural Support for Programming Languages and Operating Systems - ASPLOS. 4 ed. Vol. 26. Publ by ACM. 1991. p. 260-268
Freudenthal, Eric ; Gottlieb, Allan. / Process coordination with fetch-and-increment. International Conference on Architectural Support for Programming Languages and Operating Systems - ASPLOS. editor / Anon. Vol. 26 4. ed. Publ by ACM, 1991. pp. 260-268
@inproceedings{454045b0ccf0470fb8f6ebb25f7de12d,
title = "Process coordination with fetch-and-increment",
abstract = "The fetch-and-add (F&A) operation has been used effectively in a number of process coordination algorithms. In this paper we assess the power of fetch-and-increment (F&I) and fetch-and-decrement (F&D), which we view as restricted forms of F&A in which the only addends permitted are ±1. F&A-based algorithms that use only unit addends are thus trivially expressed with just F&I and F&D. Our primary contributions are new F&I/F&D algorithms for readers/writers coordination and barrier synchronization for dynamically-sized groups. We also restructure an existing F&A-based algorithm for queues-with-multiplicity to obtain an algorithm using just F&I and F&D. When executed on certain hardware architectures, most of these algorithms are free of serial bottlenecks. We also discuss a general technique for implementing F&A using F&I/F&D at a cost logarithmic in the number of processors.",
author = "Eric Freudenthal and Allan Gottlieb",
year = "1991",
month = "4",
language = "English (US)",
volume = "26",
pages = "260--268",
editor = "Anon",
booktitle = "International Conference on Architectural Support for Programming Languages and Operating Systems - ASPLOS",
publisher = "Publ by ACM",
edition = "4",

}

TY - GEN

T1 - Process coordination with fetch-and-increment

AU - Freudenthal, Eric

AU - Gottlieb, Allan

PY - 1991/4

Y1 - 1991/4

N2 - The fetch-and-add (F&A) operation has been used effectively in a number of process coordination algorithms. In this paper we assess the power of fetch-and-increment (F&I) and fetch-and-decrement (F&D), which we view as restricted forms of F&A in which the only addends permitted are ±1. F&A-based algorithms that use only unit addends are thus trivially expressed with just F&I and F&D. Our primary contributions are new F&I/F&D algorithms for readers/writers coordination and barrier synchronization for dynamically-sized groups. We also restructure an existing F&A-based algorithm for queues-with-multiplicity to obtain an algorithm using just F&I and F&D. When executed on certain hardware architectures, most of these algorithms are free of serial bottlenecks. We also discuss a general technique for implementing F&A using F&I/F&D at a cost logarithmic in the number of processors.

AB - The fetch-and-add (F&A) operation has been used effectively in a number of process coordination algorithms. In this paper we assess the power of fetch-and-increment (F&I) and fetch-and-decrement (F&D), which we view as restricted forms of F&A in which the only addends permitted are ±1. F&A-based algorithms that use only unit addends are thus trivially expressed with just F&I and F&D. Our primary contributions are new F&I/F&D algorithms for readers/writers coordination and barrier synchronization for dynamically-sized groups. We also restructure an existing F&A-based algorithm for queues-with-multiplicity to obtain an algorithm using just F&I and F&D. When executed on certain hardware architectures, most of these algorithms are free of serial bottlenecks. We also discuss a general technique for implementing F&A using F&I/F&D at a cost logarithmic in the number of processors.

UR - http://www.scopus.com/inward/record.url?scp=0026136302&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=0026136302&partnerID=8YFLogxK

M3 - Conference contribution

VL - 26

SP - 260

EP - 268

BT - International Conference on Architectural Support for Programming Languages and Operating Systems - ASPLOS

A2 - Anon, null

PB - Publ by ACM

ER -