Parallel marching blocks

a practical isosurfacing algorithm for large data on many-core architectures.

Baoquan Liu, Gordon J. Clapworthy, Feng Dong, Enhua Wu

Research output: Contribution to journalArticle

1 Citation (Scopus)
6 Downloads (Pure)

Abstract

Interactive isosurface visualisation has been made possible by mapping algorithms to GPU architectures. However, current state‐of‐the‐art isosurfacing algorithms usually consume large amounts of GPU memory owing to the additional acceleration structures they require. As a result, the continued limitations on available GPU memory mean that they are unable to deal with the larger datasets that are now increasingly becoming prevalent.

This paper proposes a new parallel isosurface‐extraction algorithm that exploits the blocked organisation of the parallel threads found in modern many‐core platforms to achieve fast isosurface extraction and reduce the associated memory requirements. This is achieved by optimising thread co‐operation within thread‐blocks and reducing redundant computation; ultimately, an indexed triangular mesh can be produced.

Experiments have shown that the proposed algorithm is much faster (up to 10×) than state‐of‐the‐art GPU algorithms and has a much smaller memory footprint, enabling it to handle much larger datasets (up to 64×) on the same GPU.
Original languageEnglish
Pages (from-to)211-220
Number of pages10
JournalComputer Graphics Forum
Volume35
Issue number3
DOIs
Publication statusPublished - 4 Jul 2016

Fingerprint

Data storage equipment
Parallel algorithms
Visualization
Graphics processing unit
Experiments

Keywords

  • many‐core architectures
  • isosurfacing algorithm
  • parallel marching blocks

Cite this

Liu, Baoquan ; Clapworthy, Gordon J. ; Dong, Feng ; Wu, Enhua . / Parallel marching blocks : a practical isosurfacing algorithm for large data on many-core architectures. In: Computer Graphics Forum. 2016 ; Vol. 35, No. 3. pp. 211-220.
@article{bb4cbeb901984af69c7ebf607d37981b,
title = "Parallel marching blocks: a practical isosurfacing algorithm for large data on many-core architectures.",
abstract = "Interactive isosurface visualisation has been made possible by mapping algorithms to GPU architectures. However, current state‐of‐the‐art isosurfacing algorithms usually consume large amounts of GPU memory owing to the additional acceleration structures they require. As a result, the continued limitations on available GPU memory mean that they are unable to deal with the larger datasets that are now increasingly becoming prevalent.This paper proposes a new parallel isosurface‐extraction algorithm that exploits the blocked organisation of the parallel threads found in modern many‐core platforms to achieve fast isosurface extraction and reduce the associated memory requirements. This is achieved by optimising thread co‐operation within thread‐blocks and reducing redundant computation; ultimately, an indexed triangular mesh can be produced.Experiments have shown that the proposed algorithm is much faster (up to 10×) than state‐of‐the‐art GPU algorithms and has a much smaller memory footprint, enabling it to handle much larger datasets (up to 64×) on the same GPU.",
keywords = "many‐core architectures, isosurfacing algorithm, parallel marching blocks",
author = "Baoquan Liu and Clapworthy, {Gordon J.} and Feng Dong and Enhua Wu",
year = "2016",
month = "7",
day = "4",
doi = "10.1111/cgf.12897",
language = "English",
volume = "35",
pages = "211--220",
number = "3",

}

Parallel marching blocks : a practical isosurfacing algorithm for large data on many-core architectures. / Liu, Baoquan; Clapworthy, Gordon J.; Dong, Feng; Wu, Enhua .

In: Computer Graphics Forum, Vol. 35, No. 3, 04.07.2016, p. 211-220.

Research output: Contribution to journalArticle

TY - JOUR

T1 - Parallel marching blocks

T2 - a practical isosurfacing algorithm for large data on many-core architectures.

AU - Liu, Baoquan

AU - Clapworthy, Gordon J.

AU - Dong, Feng

AU - Wu, Enhua

PY - 2016/7/4

Y1 - 2016/7/4

N2 - Interactive isosurface visualisation has been made possible by mapping algorithms to GPU architectures. However, current state‐of‐the‐art isosurfacing algorithms usually consume large amounts of GPU memory owing to the additional acceleration structures they require. As a result, the continued limitations on available GPU memory mean that they are unable to deal with the larger datasets that are now increasingly becoming prevalent.This paper proposes a new parallel isosurface‐extraction algorithm that exploits the blocked organisation of the parallel threads found in modern many‐core platforms to achieve fast isosurface extraction and reduce the associated memory requirements. This is achieved by optimising thread co‐operation within thread‐blocks and reducing redundant computation; ultimately, an indexed triangular mesh can be produced.Experiments have shown that the proposed algorithm is much faster (up to 10×) than state‐of‐the‐art GPU algorithms and has a much smaller memory footprint, enabling it to handle much larger datasets (up to 64×) on the same GPU.

AB - Interactive isosurface visualisation has been made possible by mapping algorithms to GPU architectures. However, current state‐of‐the‐art isosurfacing algorithms usually consume large amounts of GPU memory owing to the additional acceleration structures they require. As a result, the continued limitations on available GPU memory mean that they are unable to deal with the larger datasets that are now increasingly becoming prevalent.This paper proposes a new parallel isosurface‐extraction algorithm that exploits the blocked organisation of the parallel threads found in modern many‐core platforms to achieve fast isosurface extraction and reduce the associated memory requirements. This is achieved by optimising thread co‐operation within thread‐blocks and reducing redundant computation; ultimately, an indexed triangular mesh can be produced.Experiments have shown that the proposed algorithm is much faster (up to 10×) than state‐of‐the‐art GPU algorithms and has a much smaller memory footprint, enabling it to handle much larger datasets (up to 64×) on the same GPU.

KW - many‐core architectures

KW - isosurfacing algorithm

KW - parallel marching blocks

U2 - 10.1111/cgf.12897

DO - 10.1111/cgf.12897

M3 - Article

VL - 35

SP - 211

EP - 220

IS - 3

ER -