Estimating minimum parallel execution time of loops with loop-carried dependencies

Tsuneo Nakanishi, Kazuki Joe, Constantine D. Polychronopoulos, Keijiro Araki, Akira Fukuda

Research output: Contribution to journalArticle

Abstract

The article proposes a method of calculating the minimum parallel execution time of loops. The loop is completely unrolled and the task graph is considered. By assigning the execution time of the corresponding task and the communication time related to the dependency as costs to the nodes and edges of the task graph, the cost of the critical path which is the path for which the total cost of the nodes and edges composing the path is the maximum, gives the minimum parallel execution time of the loops. It is not desirable, however, in considering the computation time and the required memory capacity, to unroll the loops completely. The method presented here formulates the problem as the integer programming problem, and calculates the cost of the critical path without rolling the loops at all. In this study, a branch and bound algorithm that solves the integer programming problem is implemented. The implemented algorithm unrolls the loops and determines the critical path on the task graph. As a result of evaluation using Livermore's benchmark kernel, it is verified that the implemented algorithm can be executed in a sufficiently practical time, regardless of the size (number of iterations) of the loops.

Original languageEnglish
Pages (from-to)57-68
Number of pages12
JournalSystems and Computers in Japan
Volume30
Issue number10
DOIs
Publication statusPublished - Sep 1 1999

Fingerprint

Execution Time
Task Graph
Integer programming
Critical Path
Costs
Integer Programming
Path
Data storage equipment
Branch and Bound Algorithm
Vertex of a graph
Communication
Benchmark
kernel
Iteration
Calculate
Evaluation

All Science Journal Classification (ASJC) codes

  • Theoretical Computer Science
  • Information Systems
  • Hardware and Architecture
  • Computational Theory and Mathematics

Cite this

Estimating minimum parallel execution time of loops with loop-carried dependencies. / Nakanishi, Tsuneo; Joe, Kazuki; Polychronopoulos, Constantine D.; Araki, Keijiro; Fukuda, Akira.

In: Systems and Computers in Japan, Vol. 30, No. 10, 01.09.1999, p. 57-68.

Research output: Contribution to journalArticle

Nakanishi, Tsuneo ; Joe, Kazuki ; Polychronopoulos, Constantine D. ; Araki, Keijiro ; Fukuda, Akira. / Estimating minimum parallel execution time of loops with loop-carried dependencies. In: Systems and Computers in Japan. 1999 ; Vol. 30, No. 10. pp. 57-68.
@article{49579e2501334bbe86522d331065dcfb,
title = "Estimating minimum parallel execution time of loops with loop-carried dependencies",
abstract = "The article proposes a method of calculating the minimum parallel execution time of loops. The loop is completely unrolled and the task graph is considered. By assigning the execution time of the corresponding task and the communication time related to the dependency as costs to the nodes and edges of the task graph, the cost of the critical path which is the path for which the total cost of the nodes and edges composing the path is the maximum, gives the minimum parallel execution time of the loops. It is not desirable, however, in considering the computation time and the required memory capacity, to unroll the loops completely. The method presented here formulates the problem as the integer programming problem, and calculates the cost of the critical path without rolling the loops at all. In this study, a branch and bound algorithm that solves the integer programming problem is implemented. The implemented algorithm unrolls the loops and determines the critical path on the task graph. As a result of evaluation using Livermore's benchmark kernel, it is verified that the implemented algorithm can be executed in a sufficiently practical time, regardless of the size (number of iterations) of the loops.",
author = "Tsuneo Nakanishi and Kazuki Joe and Polychronopoulos, {Constantine D.} and Keijiro Araki and Akira Fukuda",
year = "1999",
month = "9",
day = "1",
doi = "10.1002/(SICI)1520-684X(199909)30:10<57::AID-SCJ6>3.0.CO;2-N",
language = "English",
volume = "30",
pages = "57--68",
journal = "Systems and Computers in Japan",
issn = "0882-1666",
publisher = "John Wiley and Sons Inc.",
number = "10",

}

TY - JOUR

T1 - Estimating minimum parallel execution time of loops with loop-carried dependencies

AU - Nakanishi, Tsuneo

AU - Joe, Kazuki

AU - Polychronopoulos, Constantine D.

AU - Araki, Keijiro

AU - Fukuda, Akira

PY - 1999/9/1

Y1 - 1999/9/1

N2 - The article proposes a method of calculating the minimum parallel execution time of loops. The loop is completely unrolled and the task graph is considered. By assigning the execution time of the corresponding task and the communication time related to the dependency as costs to the nodes and edges of the task graph, the cost of the critical path which is the path for which the total cost of the nodes and edges composing the path is the maximum, gives the minimum parallel execution time of the loops. It is not desirable, however, in considering the computation time and the required memory capacity, to unroll the loops completely. The method presented here formulates the problem as the integer programming problem, and calculates the cost of the critical path without rolling the loops at all. In this study, a branch and bound algorithm that solves the integer programming problem is implemented. The implemented algorithm unrolls the loops and determines the critical path on the task graph. As a result of evaluation using Livermore's benchmark kernel, it is verified that the implemented algorithm can be executed in a sufficiently practical time, regardless of the size (number of iterations) of the loops.

AB - The article proposes a method of calculating the minimum parallel execution time of loops. The loop is completely unrolled and the task graph is considered. By assigning the execution time of the corresponding task and the communication time related to the dependency as costs to the nodes and edges of the task graph, the cost of the critical path which is the path for which the total cost of the nodes and edges composing the path is the maximum, gives the minimum parallel execution time of the loops. It is not desirable, however, in considering the computation time and the required memory capacity, to unroll the loops completely. The method presented here formulates the problem as the integer programming problem, and calculates the cost of the critical path without rolling the loops at all. In this study, a branch and bound algorithm that solves the integer programming problem is implemented. The implemented algorithm unrolls the loops and determines the critical path on the task graph. As a result of evaluation using Livermore's benchmark kernel, it is verified that the implemented algorithm can be executed in a sufficiently practical time, regardless of the size (number of iterations) of the loops.

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

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

U2 - 10.1002/(SICI)1520-684X(199909)30:10<57::AID-SCJ6>3.0.CO;2-N

DO - 10.1002/(SICI)1520-684X(199909)30:10<57::AID-SCJ6>3.0.CO;2-N

M3 - Article

AN - SCOPUS:0033365752

VL - 30

SP - 57

EP - 68

JO - Systems and Computers in Japan

JF - Systems and Computers in Japan

SN - 0882-1666

IS - 10

ER -