Parallel convexity algorithms for digitized images on a linear array of processors

Hussein Alnuweiri, V. K. Prasanna Kumar

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Abstract

Efficient implementation of global computations on a, linear array of processors is complicated due to the small communication bandwidth and the large communication diameter of the array. This paper presents efficient parallel techniques for partitioning, movement, and reduction of data on linear arrays. Also, efficient data structures are used to enable fast sequential access of query points within each processor. This combination of serial and parallel techniques is used to derive an optimal parallel algorithm for computing the convex hull of each connected region in an n × n image. The algorithm takes O(n2/p) time on a linear array with p processors, where 1 ≤ p ≤ n/logn. This result is processor-time optimal since an optimal sequential algorithm takes O(n2) to solve the problem. Thus, a linear array with n/log n processors can solve the above problem in O(nlogn) time. In comparison, a two dimensional mesh-connected array of processors can solve this problem in O(n) time using n2 processors. The processor-time product for the mesh is 0(n3), which is not optimal.

Original languageEnglish
Title of host publicationAlgorithms - International Symposium SlGAL 1990, Proceedings
PublisherSpringer Verlag
Pages397-406
Number of pages10
ISBN (Print)9783540529217
DOIs
Publication statusPublished - 1 Jan 1990
Externally publishedYes
Event1st SIGAL International Symposium on Algorithms, 1990 - Tokyo, Japan
Duration: 16 Aug 199018 Aug 1990

Publication series

NameLecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)
Volume450 LNCS
ISSN (Print)0302-9743
ISSN (Electronic)1611-3349

Other

Other1st SIGAL International Symposium on Algorithms, 1990
CountryJapan
CityTokyo
Period16/8/9018/8/90

Fingerprint

Linear Array
Parallel algorithms
Convexity
Communication
Data structures
Optimal Algorithm
Bandwidth
Mesh
Sequential Algorithm
Efficient Implementation
Convex Hull
Parallel Algorithms
Partitioning
Data Structures
Query
Computing

ASJC Scopus subject areas

  • Theoretical Computer Science
  • Computer Science(all)

Cite this

Alnuweiri, H., & Prasanna Kumar, V. K. (1990). Parallel convexity algorithms for digitized images on a linear array of processors. In Algorithms - International Symposium SlGAL 1990, Proceedings (pp. 397-406). (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 450 LNCS). Springer Verlag. https://doi.org/10.1007/3-540-52921-7_89

Parallel convexity algorithms for digitized images on a linear array of processors. / Alnuweiri, Hussein; Prasanna Kumar, V. K.

Algorithms - International Symposium SlGAL 1990, Proceedings. Springer Verlag, 1990. p. 397-406 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 450 LNCS).

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Alnuweiri, H & Prasanna Kumar, VK 1990, Parallel convexity algorithms for digitized images on a linear array of processors. in Algorithms - International Symposium SlGAL 1990, Proceedings. Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), vol. 450 LNCS, Springer Verlag, pp. 397-406, 1st SIGAL International Symposium on Algorithms, 1990, Tokyo, Japan, 16/8/90. https://doi.org/10.1007/3-540-52921-7_89
Alnuweiri H, Prasanna Kumar VK. Parallel convexity algorithms for digitized images on a linear array of processors. In Algorithms - International Symposium SlGAL 1990, Proceedings. Springer Verlag. 1990. p. 397-406. (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)). https://doi.org/10.1007/3-540-52921-7_89
Alnuweiri, Hussein ; Prasanna Kumar, V. K. / Parallel convexity algorithms for digitized images on a linear array of processors. Algorithms - International Symposium SlGAL 1990, Proceedings. Springer Verlag, 1990. pp. 397-406 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)).
@inproceedings{bd91d02da3ed4dfea5ee742afd5af139,
title = "Parallel convexity algorithms for digitized images on a linear array of processors",
abstract = "Efficient implementation of global computations on a, linear array of processors is complicated due to the small communication bandwidth and the large communication diameter of the array. This paper presents efficient parallel techniques for partitioning, movement, and reduction of data on linear arrays. Also, efficient data structures are used to enable fast sequential access of query points within each processor. This combination of serial and parallel techniques is used to derive an optimal parallel algorithm for computing the convex hull of each connected region in an n × n image. The algorithm takes O(n2/p) time on a linear array with p processors, where 1 ≤ p ≤ n/logn. This result is processor-time optimal since an optimal sequential algorithm takes O(n2) to solve the problem. Thus, a linear array with n/log n processors can solve the above problem in O(nlogn) time. In comparison, a two dimensional mesh-connected array of processors can solve this problem in O(n) time using n2 processors. The processor-time product for the mesh is 0(n3), which is not optimal.",
author = "Hussein Alnuweiri and {Prasanna Kumar}, {V. K.}",
year = "1990",
month = "1",
day = "1",
doi = "10.1007/3-540-52921-7_89",
language = "English",
isbn = "9783540529217",
series = "Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)",
publisher = "Springer Verlag",
pages = "397--406",
booktitle = "Algorithms - International Symposium SlGAL 1990, Proceedings",

}

TY - GEN

T1 - Parallel convexity algorithms for digitized images on a linear array of processors

AU - Alnuweiri, Hussein

AU - Prasanna Kumar, V. K.

PY - 1990/1/1

Y1 - 1990/1/1

N2 - Efficient implementation of global computations on a, linear array of processors is complicated due to the small communication bandwidth and the large communication diameter of the array. This paper presents efficient parallel techniques for partitioning, movement, and reduction of data on linear arrays. Also, efficient data structures are used to enable fast sequential access of query points within each processor. This combination of serial and parallel techniques is used to derive an optimal parallel algorithm for computing the convex hull of each connected region in an n × n image. The algorithm takes O(n2/p) time on a linear array with p processors, where 1 ≤ p ≤ n/logn. This result is processor-time optimal since an optimal sequential algorithm takes O(n2) to solve the problem. Thus, a linear array with n/log n processors can solve the above problem in O(nlogn) time. In comparison, a two dimensional mesh-connected array of processors can solve this problem in O(n) time using n2 processors. The processor-time product for the mesh is 0(n3), which is not optimal.

AB - Efficient implementation of global computations on a, linear array of processors is complicated due to the small communication bandwidth and the large communication diameter of the array. This paper presents efficient parallel techniques for partitioning, movement, and reduction of data on linear arrays. Also, efficient data structures are used to enable fast sequential access of query points within each processor. This combination of serial and parallel techniques is used to derive an optimal parallel algorithm for computing the convex hull of each connected region in an n × n image. The algorithm takes O(n2/p) time on a linear array with p processors, where 1 ≤ p ≤ n/logn. This result is processor-time optimal since an optimal sequential algorithm takes O(n2) to solve the problem. Thus, a linear array with n/log n processors can solve the above problem in O(nlogn) time. In comparison, a two dimensional mesh-connected array of processors can solve this problem in O(n) time using n2 processors. The processor-time product for the mesh is 0(n3), which is not optimal.

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

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

U2 - 10.1007/3-540-52921-7_89

DO - 10.1007/3-540-52921-7_89

M3 - Conference contribution

AN - SCOPUS:85031809173

SN - 9783540529217

T3 - Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)

SP - 397

EP - 406

BT - Algorithms - International Symposium SlGAL 1990, Proceedings

PB - Springer Verlag

ER -