Task granularity analysis in logic programs

Saumya K. Debray; Nai Wei Lin; Manuel Hermenegildo

doi:10.1145/93542.93564

Task granularity analysis in logic programs

Saumya K. Debray, Nai Wei Lin, Manuel Hermenegildo

Computer Science

Research output: Chapter in Book/Report/Conference proceeding › Conference contribution

15 Scopus citations

Abstract

While logic programming languages offer a great deal of scope for parallelism, there is usually some overhead associated with the execution of goals in parallel because of the work involved in task creation and scheduling. In practice, therefore, the "granularity" of a goal, i.e. an estimate of the work available under it, should be taken into account when deciding whether or not to execute a goal concurrently as a separate task. This paper describes a method for estimating the granularity of a goal at compile time. The runtime overhead associated with our approach is usually quite small, and the performance improvements resulting from the incorporation of grainsize control can be quite good. This is shown by means of experimental results.

Original language	English (US)
Title of host publication	Proceedings of the ACM SIGPLAN 1990 Conference on Programming Language Design and Implementation, PLDI 1990
Publisher	Association for Computing Machinery
Pages	174-188
Number of pages	15
ISBN (Electronic)	0897913647
DOIs	https://doi.org/10.1145/93542.93564
State	Published - Jun 1 1990
Event	ACM SIGPLAN 1990 Conference on Programming Language Design and Implementation, PLDI 1990 - White Plains, United States Duration: Jun 20 1990 → Jun 22 1990

Publication series

Name	Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)
Volume	20-22-June-1990

Other

Other	ACM SIGPLAN 1990 Conference on Programming Language Design and Implementation, PLDI 1990
Country/Territory	United States
City	White Plains
Period	6/20/90 → 6/22/90

ASJC Scopus subject areas

Software

Access to Document

10.1145/93542.93564

Cite this

Debray, S. K., Lin, N. W., & Hermenegildo, M. (1990). Task granularity analysis in logic programs. In Proceedings of the ACM SIGPLAN 1990 Conference on Programming Language Design and Implementation, PLDI 1990 (pp. 174-188). (Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI); Vol. 20-22-June-1990). Association for Computing Machinery. https://doi.org/10.1145/93542.93564

Task granularity analysis in logic programs. / Debray, Saumya K.; Lin, Nai Wei; Hermenegildo, Manuel.

Proceedings of the ACM SIGPLAN 1990 Conference on Programming Language Design and Implementation, PLDI 1990. Association for Computing Machinery, 1990. p. 174-188 (Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI); Vol. 20-22-June-1990).

Research output: Chapter in Book/Report/Conference proceeding › Conference contribution

Debray, SK, Lin, NW & Hermenegildo, M 1990, Task granularity analysis in logic programs. in Proceedings of the ACM SIGPLAN 1990 Conference on Programming Language Design and Implementation, PLDI 1990. Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), vol. 20-22-June-1990, Association for Computing Machinery, pp. 174-188, ACM SIGPLAN 1990 Conference on Programming Language Design and Implementation, PLDI 1990, White Plains, United States, 6/20/90. https://doi.org/10.1145/93542.93564

Debray SK, Lin NW, Hermenegildo M. Task granularity analysis in logic programs. In Proceedings of the ACM SIGPLAN 1990 Conference on Programming Language Design and Implementation, PLDI 1990. Association for Computing Machinery. 1990. p. 174-188. (Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)). doi: 10.1145/93542.93564

@inproceedings{ca78a606beb648efaa0ec246d1f9e833,

title = "Task granularity analysis in logic programs",

abstract = "While logic programming languages offer a great deal of scope for parallelism, there is usually some overhead associated with the execution of goals in parallel because of the work involved in task creation and scheduling. In practice, therefore, the {"}granularity{"} of a goal, i.e. an estimate of the work available under it, should be taken into account when deciding whether or not to execute a goal concurrently as a separate task. This paper describes a method for estimating the granularity of a goal at compile time. The runtime overhead associated with our approach is usually quite small, and the performance improvements resulting from the incorporation of grainsize control can be quite good. This is shown by means of experimental results.",

author = "Debray, {Saumya K.} and Lin, {Nai Wei} and Manuel Hermenegildo",

note = "Publisher Copyright: {\textcopyright} 1990 ACM.; ACM SIGPLAN 1990 Conference on Programming Language Design and Implementation, PLDI 1990 ; Conference date: 20-06-1990 Through 22-06-1990",

year = "1990",

month = jun,

day = "1",

doi = "10.1145/93542.93564",

language = "English (US)",

series = "Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)",

publisher = "Association for Computing Machinery",

pages = "174--188",

booktitle = "Proceedings of the ACM SIGPLAN 1990 Conference on Programming Language Design and Implementation, PLDI 1990",

}

TY - GEN

T1 - Task granularity analysis in logic programs

AU - Debray, Saumya K.

AU - Lin, Nai Wei

AU - Hermenegildo, Manuel

PY - 1990/6/1

Y1 - 1990/6/1

N2 - While logic programming languages offer a great deal of scope for parallelism, there is usually some overhead associated with the execution of goals in parallel because of the work involved in task creation and scheduling. In practice, therefore, the "granularity" of a goal, i.e. an estimate of the work available under it, should be taken into account when deciding whether or not to execute a goal concurrently as a separate task. This paper describes a method for estimating the granularity of a goal at compile time. The runtime overhead associated with our approach is usually quite small, and the performance improvements resulting from the incorporation of grainsize control can be quite good. This is shown by means of experimental results.

AB - While logic programming languages offer a great deal of scope for parallelism, there is usually some overhead associated with the execution of goals in parallel because of the work involved in task creation and scheduling. In practice, therefore, the "granularity" of a goal, i.e. an estimate of the work available under it, should be taken into account when deciding whether or not to execute a goal concurrently as a separate task. This paper describes a method for estimating the granularity of a goal at compile time. The runtime overhead associated with our approach is usually quite small, and the performance improvements resulting from the incorporation of grainsize control can be quite good. This is shown by means of experimental results.

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

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

U2 - 10.1145/93542.93564

DO - 10.1145/93542.93564

M3 - Conference contribution

AN - SCOPUS:84963621160

T3 - Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)

SP - 174

EP - 188

BT - Proceedings of the ACM SIGPLAN 1990 Conference on Programming Language Design and Implementation, PLDI 1990

PB - Association for Computing Machinery

T2 - ACM SIGPLAN 1990 Conference on Programming Language Design and Implementation, PLDI 1990

Y2 - 20 June 1990 through 22 June 1990

ER -

Task granularity analysis in logic programs

Abstract

Publication series

Other

ASJC Scopus subject areas

Access to Document

Other files and links

Fingerprint

Cite this