A comparative analysis of fine-grain threads packages

Gregory W. Price, David K Lowenthal

Research output: Contribution to journalArticle

8 Citations (Scopus)

Abstract

The rising availability of multiprocessing platforms has increased the importance of providing programming models that allow users to express parallelism simply, portably, and efficiently. One popular way to write parallel programs is to use threads for concurrent sections of code. User-level threads packages allow programmers to implement multithreaded programs in which thread creation, thread management, and thread synchronization are relatively inexpensive. Fine-grain programs are multithreaded programs in which the work is divided into a large number of threads, where each thread contains a relatively small amount of work. The potential benefit of large numbers of threads include easier load balancing, better scalability, greater potential for overlapping communication and computation, and improved platform-independence. However, fine-grain programs are largely considered inefficent due to the overheads involved in managing numerous threads. In this paper, we survey several thread packages that take different approaches to the problem of efficiently supporting the creation and management of large numbers of fine-grain threads. Each package is compared based on its level of support of the general thread model as well as its performance on a set of fine-grain parallel programs. We find that while the thread packages we tested may support medium-grain parallelism efficiently, they do not always support fine-grain parallelism. Although no package supports fine-grain parallelism and a general thread model, we believe that it can potentially be done with help from the compiler.

Original languageEnglish (US)
Pages (from-to)1050-1063
Number of pages14
JournalJournal of Parallel and Distributed Computing
Volume63
Issue number11
DOIs
StatePublished - Nov 2003
Externally publishedYes

Fingerprint

Comparative Analysis
Thread
Resource allocation
Scalability
Synchronization
Parallelism
Availability
Communication
Parallel Programs
Multiprocessing
Load Balancing
Compiler
Programming Model
Overlapping
Concurrent
Express

Keywords

  • Fine-grain parallelism
  • Load balancing
  • Threads

ASJC Scopus subject areas

  • Computer Science Applications
  • Hardware and Architecture
  • Control and Systems Engineering

Cite this

A comparative analysis of fine-grain threads packages. / Price, Gregory W.; Lowenthal, David K.

In: Journal of Parallel and Distributed Computing, Vol. 63, No. 11, 11.2003, p. 1050-1063.

Research output: Contribution to journalArticle

@article{d89c5bcd9e1d45f0845b0309acea6e30,
title = "A comparative analysis of fine-grain threads packages",
abstract = "The rising availability of multiprocessing platforms has increased the importance of providing programming models that allow users to express parallelism simply, portably, and efficiently. One popular way to write parallel programs is to use threads for concurrent sections of code. User-level threads packages allow programmers to implement multithreaded programs in which thread creation, thread management, and thread synchronization are relatively inexpensive. Fine-grain programs are multithreaded programs in which the work is divided into a large number of threads, where each thread contains a relatively small amount of work. The potential benefit of large numbers of threads include easier load balancing, better scalability, greater potential for overlapping communication and computation, and improved platform-independence. However, fine-grain programs are largely considered inefficent due to the overheads involved in managing numerous threads. In this paper, we survey several thread packages that take different approaches to the problem of efficiently supporting the creation and management of large numbers of fine-grain threads. Each package is compared based on its level of support of the general thread model as well as its performance on a set of fine-grain parallel programs. We find that while the thread packages we tested may support medium-grain parallelism efficiently, they do not always support fine-grain parallelism. Although no package supports fine-grain parallelism and a general thread model, we believe that it can potentially be done with help from the compiler.",
keywords = "Fine-grain parallelism, Load balancing, Threads",
author = "Price, {Gregory W.} and Lowenthal, {David K}",
year = "2003",
month = "11",
doi = "10.1016/j.jpdc.2003.06.001",
language = "English (US)",
volume = "63",
pages = "1050--1063",
journal = "Journal of Parallel and Distributed Computing",
issn = "0743-7315",
publisher = "Academic Press Inc.",
number = "11",

}

TY - JOUR

T1 - A comparative analysis of fine-grain threads packages

AU - Price, Gregory W.

AU - Lowenthal, David K

PY - 2003/11

Y1 - 2003/11

N2 - The rising availability of multiprocessing platforms has increased the importance of providing programming models that allow users to express parallelism simply, portably, and efficiently. One popular way to write parallel programs is to use threads for concurrent sections of code. User-level threads packages allow programmers to implement multithreaded programs in which thread creation, thread management, and thread synchronization are relatively inexpensive. Fine-grain programs are multithreaded programs in which the work is divided into a large number of threads, where each thread contains a relatively small amount of work. The potential benefit of large numbers of threads include easier load balancing, better scalability, greater potential for overlapping communication and computation, and improved platform-independence. However, fine-grain programs are largely considered inefficent due to the overheads involved in managing numerous threads. In this paper, we survey several thread packages that take different approaches to the problem of efficiently supporting the creation and management of large numbers of fine-grain threads. Each package is compared based on its level of support of the general thread model as well as its performance on a set of fine-grain parallel programs. We find that while the thread packages we tested may support medium-grain parallelism efficiently, they do not always support fine-grain parallelism. Although no package supports fine-grain parallelism and a general thread model, we believe that it can potentially be done with help from the compiler.

AB - The rising availability of multiprocessing platforms has increased the importance of providing programming models that allow users to express parallelism simply, portably, and efficiently. One popular way to write parallel programs is to use threads for concurrent sections of code. User-level threads packages allow programmers to implement multithreaded programs in which thread creation, thread management, and thread synchronization are relatively inexpensive. Fine-grain programs are multithreaded programs in which the work is divided into a large number of threads, where each thread contains a relatively small amount of work. The potential benefit of large numbers of threads include easier load balancing, better scalability, greater potential for overlapping communication and computation, and improved platform-independence. However, fine-grain programs are largely considered inefficent due to the overheads involved in managing numerous threads. In this paper, we survey several thread packages that take different approaches to the problem of efficiently supporting the creation and management of large numbers of fine-grain threads. Each package is compared based on its level of support of the general thread model as well as its performance on a set of fine-grain parallel programs. We find that while the thread packages we tested may support medium-grain parallelism efficiently, they do not always support fine-grain parallelism. Although no package supports fine-grain parallelism and a general thread model, we believe that it can potentially be done with help from the compiler.

KW - Fine-grain parallelism

KW - Load balancing

KW - Threads

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

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

U2 - 10.1016/j.jpdc.2003.06.001

DO - 10.1016/j.jpdc.2003.06.001

M3 - Article

VL - 63

SP - 1050

EP - 1063

JO - Journal of Parallel and Distributed Computing

JF - Journal of Parallel and Distributed Computing

SN - 0743-7315

IS - 11

ER -