DISTRIBUTED EXECUTION OF FUNCTIONAL PROGRAMS USING SERIAL COMBINATORS.

Paul Hudak, Benjamin Goldberg

Research output: Contribution to journalArticle

Abstract

A general strategy for automatically decomposing and dynamically distributing a functional program is discussed. The strategy is suitable for parallel execution on multiprocessor architectures with no shared memory. It borrows ideas from data flow and reduction machine research on the one hand, and from conventional compiler technology for sequential machines on the other. One of the more troublesome issues in such a system is choosing the right granularity for the parallel tasks. As a solution, the authors describe a program transformation technique based on serial combinators that offers in some sense just the right granularity for this style of computing, and that can be fine-tuned for particular multiprocessor architectures. Simulation demonstrates the success of this approach.

Original languageEnglish (US)
Pages (from-to)881-890
Number of pages10
JournalIEEE Transactions on Computers
VolumeC-34
Issue number10
StatePublished - Oct 1985

Fingerprint

Sequential machines
Multiprocessor
Granularity
Data storage equipment
Program Transformation
Data Reduction
Shared Memory
Data Flow
Compiler
Computing
Demonstrate
Simulation
Architecture
Strategy
Style

ASJC Scopus subject areas

  • Hardware and Architecture
  • Electrical and Electronic Engineering

Cite this

DISTRIBUTED EXECUTION OF FUNCTIONAL PROGRAMS USING SERIAL COMBINATORS. / Hudak, Paul; Goldberg, Benjamin.

In: IEEE Transactions on Computers, Vol. C-34, No. 10, 10.1985, p. 881-890.

Research output: Contribution to journalArticle

@article{9e5b7f5f32ab4730b30636e8dccee93f,
title = "DISTRIBUTED EXECUTION OF FUNCTIONAL PROGRAMS USING SERIAL COMBINATORS.",
abstract = "A general strategy for automatically decomposing and dynamically distributing a functional program is discussed. The strategy is suitable for parallel execution on multiprocessor architectures with no shared memory. It borrows ideas from data flow and reduction machine research on the one hand, and from conventional compiler technology for sequential machines on the other. One of the more troublesome issues in such a system is choosing the right granularity for the parallel tasks. As a solution, the authors describe a program transformation technique based on serial combinators that offers in some sense just the right granularity for this style of computing, and that can be fine-tuned for particular multiprocessor architectures. Simulation demonstrates the success of this approach.",
author = "Paul Hudak and Benjamin Goldberg",
year = "1985",
month = "10",
language = "English (US)",
volume = "C-34",
pages = "881--890",
journal = "IEEE Transactions on Computers",
issn = "0018-9340",
publisher = "IEEE Computer Society",
number = "10",

}

TY - JOUR

T1 - DISTRIBUTED EXECUTION OF FUNCTIONAL PROGRAMS USING SERIAL COMBINATORS.

AU - Hudak, Paul

AU - Goldberg, Benjamin

PY - 1985/10

Y1 - 1985/10

N2 - A general strategy for automatically decomposing and dynamically distributing a functional program is discussed. The strategy is suitable for parallel execution on multiprocessor architectures with no shared memory. It borrows ideas from data flow and reduction machine research on the one hand, and from conventional compiler technology for sequential machines on the other. One of the more troublesome issues in such a system is choosing the right granularity for the parallel tasks. As a solution, the authors describe a program transformation technique based on serial combinators that offers in some sense just the right granularity for this style of computing, and that can be fine-tuned for particular multiprocessor architectures. Simulation demonstrates the success of this approach.

AB - A general strategy for automatically decomposing and dynamically distributing a functional program is discussed. The strategy is suitable for parallel execution on multiprocessor architectures with no shared memory. It borrows ideas from data flow and reduction machine research on the one hand, and from conventional compiler technology for sequential machines on the other. One of the more troublesome issues in such a system is choosing the right granularity for the parallel tasks. As a solution, the authors describe a program transformation technique based on serial combinators that offers in some sense just the right granularity for this style of computing, and that can be fine-tuned for particular multiprocessor architectures. Simulation demonstrates the success of this approach.

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

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

M3 - Article

VL - C-34

SP - 881

EP - 890

JO - IEEE Transactions on Computers

JF - IEEE Transactions on Computers

SN - 0018-9340

IS - 10

ER -