Basic Techniques for the Efficient Coordination of Very Large Numbers of Cooperating Sequential Processors

Allan Gottlieb, Boris D. Lubachevsky

Research output: Contribution to journalArticle

Abstract

In this paper we implement several basic operating system primitives by using a “replace-add” operation, which can supersede the standard “test and set” and which appears to be a universal primitive for efficiently coordinating large numbers of independently acting sequential processors. We also present a hardware implementation of replace-add that permits multiple replace-adds to be processed nearly as efficiently as loads and stores. Moreover, the crucial special case of concurrent replace-adds updating the same variable is handled particularly well: If every processing element simultaneously addresses a replace-add at the same variable, all these requests are satisfied in the time required to process just one request.

Original languageEnglish (US)
Pages (from-to)164-189
Number of pages26
JournalACM Transactions on Programming Languages and Systems
Volume5
Issue number2
DOIs
StatePublished - Jan 4 1983

Fingerprint

Hardware
Processing

Keywords

  • network
  • Parallel processing
  • replace-add
  • synchronization
  • ultracomputer

ASJC Scopus subject areas

  • Software

Cite this

Basic Techniques for the Efficient Coordination of Very Large Numbers of Cooperating Sequential Processors. / Gottlieb, Allan; Lubachevsky, Boris D.

In: ACM Transactions on Programming Languages and Systems, Vol. 5, No. 2, 04.01.1983, p. 164-189.

Research output: Contribution to journalArticle

@article{838e4d13cd054a97b974116f590e82e6,
title = "Basic Techniques for the Efficient Coordination of Very Large Numbers of Cooperating Sequential Processors",
abstract = "In this paper we implement several basic operating system primitives by using a “replace-add” operation, which can supersede the standard “test and set” and which appears to be a universal primitive for efficiently coordinating large numbers of independently acting sequential processors. We also present a hardware implementation of replace-add that permits multiple replace-adds to be processed nearly as efficiently as loads and stores. Moreover, the crucial special case of concurrent replace-adds updating the same variable is handled particularly well: If every processing element simultaneously addresses a replace-add at the same variable, all these requests are satisfied in the time required to process just one request.",
keywords = "network, Parallel processing, replace-add, synchronization, ultracomputer",
author = "Allan Gottlieb and Lubachevsky, {Boris D.}",
year = "1983",
month = "1",
day = "4",
doi = "10.1145/69624.357206",
language = "English (US)",
volume = "5",
pages = "164--189",
journal = "ACM Transactions on Programming Languages and Systems",
issn = "0164-0925",
publisher = "Association for Computing Machinery (ACM)",
number = "2",

}

TY - JOUR

T1 - Basic Techniques for the Efficient Coordination of Very Large Numbers of Cooperating Sequential Processors

AU - Gottlieb, Allan

AU - Lubachevsky, Boris D.

PY - 1983/1/4

Y1 - 1983/1/4

N2 - In this paper we implement several basic operating system primitives by using a “replace-add” operation, which can supersede the standard “test and set” and which appears to be a universal primitive for efficiently coordinating large numbers of independently acting sequential processors. We also present a hardware implementation of replace-add that permits multiple replace-adds to be processed nearly as efficiently as loads and stores. Moreover, the crucial special case of concurrent replace-adds updating the same variable is handled particularly well: If every processing element simultaneously addresses a replace-add at the same variable, all these requests are satisfied in the time required to process just one request.

AB - In this paper we implement several basic operating system primitives by using a “replace-add” operation, which can supersede the standard “test and set” and which appears to be a universal primitive for efficiently coordinating large numbers of independently acting sequential processors. We also present a hardware implementation of replace-add that permits multiple replace-adds to be processed nearly as efficiently as loads and stores. Moreover, the crucial special case of concurrent replace-adds updating the same variable is handled particularly well: If every processing element simultaneously addresses a replace-add at the same variable, all these requests are satisfied in the time required to process just one request.

KW - network

KW - Parallel processing

KW - replace-add

KW - synchronization

KW - ultracomputer

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

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

U2 - 10.1145/69624.357206

DO - 10.1145/69624.357206

M3 - Article

VL - 5

SP - 164

EP - 189

JO - ACM Transactions on Programming Languages and Systems

JF - ACM Transactions on Programming Languages and Systems

SN - 0164-0925

IS - 2

ER -