Pith. sign in

REVIEW 2 major objections 4 minor 59 references

GALE: Leveraging Heterogeneous Systems for Efficient Unstructured Mesh Data Analysis

T0 review · 2 major / 4 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read GALE claims that computing mesh connectivity on GPU threads while CPU threads run the analysis is fastest, reporting up to 2.7× speedup over the CPU-only task-parallel baseline at comparable memory.

desk verdict A real GPU-side localized data structure with plausible speedups, but the duplicate-free insertion is unproven and output correctness is never validated. read the letter →

arxiv 2507.15230 v3 pith:2DVDUI4O submitted 2025-07-21 cs.DC cs.GR

Guoxi Liu , Thomas Randall , Rong Ge , Federico Iuricich This is my paper · ORCID
classification cs.DCcs.GR
keywords datastructureunstructuredmeshtopologicalanalysisparallelcomputationGPUalgorithmtaskparallelismconnectivity
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The bottleneck in analyzing unstructured meshes is computing and storing connectivity — which vertices share an edge, which tetrahedra surround a triangle — and doing it competes with the analysis algorithm for the same CPU cores. GALE is a proposed fix: a localized data structure (one that computes connectivity on demand for small chunks of the mesh rather than storing it all) that splits the task between CPU and GPU, so that nearly all CPU threads run the analysis algorithm while GPU threads compute connectivity relations in bulk, coordinated by a CPU "leader" thread that batches requests. On six tetrahedral meshes and three topology-based analysis algorithms, the paper reports up to 2.7× speedup over the previous CPU-only task-parallel data structure and 4.7–5.1× over a global structure that precomputes everything, at roughly 5–40% more memory than the CPU-only localized baseline. If this holds, existing visualization algorithms — even sequential ones — could get GPU-class speedups without being rewritten.

What carries the argument

The load-bearing mechanism is a three-role producer-consumer pipeline. Consumer threads — all but a handful of the CPU cores — run the analysis algorithm and request a missing topological relation for a mesh segment; boundary relations they compute themselves, while coboundary and adjacency relations are requested from the GPU side. A leader producer thread per relation reads a dedicated FIFO queue of consumer requests, batches them, and launches a GPU kernel sized to compute $Q_r \cdot n_b \cdot t_b / t_s$ segments per request, deliberately including future segments so connectivity is ready before consumers need it. Worker producers are GPU threads that, for each segment, iterate the segment's internal and external tetrahedra and insert vertices into pre-allocated relation arrays via an atomicCAS linear-probing routine (Algorithm 2), which the paper asserts keeps the arrays duplicate-free. The tuned launch configuration — 32 GPU threads per segment, matching one warp, and 512 threads per block — is what makes the kernels and memory transfers efficient.

What would settle it

Run GALE's three benchmark algorithms on a small tetrahedral mesh whose true critical points and Morse-Smale complex are known by hand, across varied thread counts and segment sizes, and compare every output against that ground truth; separately, instrument the insertion kernel and count duplicate entries left in the relation arrays at the end of execution. Any run whose output disagrees with the reference, or any duplicate entry found after the atomic insertion routine finishes, would refute the duplicate-free guarantee that the reported speedups rest on.

Watch

Extended reading notes

Core claim

The paper's central claim is that the producer-consumer design of task-parallel localized data structures is better realized across two devices than on one: dedicate the CPU to consuming connectivity data for the analysis algorithm and push production onto the GPU. GALE implements this by keeping boundary relations (the faces of a simplex) on the CPU consumer, where they cost constant-time lookups, and delegating coboundary and adjacency relations — the cofaces and same-dimension neighbors of a simplex — to GPU kernels that compute them for a whole mesh segment at once. A leader producer thread per relation collects consumer requests from a dedicated FIFO queue, launches a kernel that precomputes the requested segments plus several future ones, and maps the results back into the algorithm's expected format. The evaluation reports that this arrangement beats the CPU-only state of the art in every configuration tested (up to 2.7×, and averaging 2.7× on the Morse-Smale workload), and beats a global precomputed structure on most datasets by 1.2×–5.1×, falling slightly behind on the largest mesh for the Morse-Smale workload. Memory stays within 5–40% of the CPU-localized baseline depending on how many relations the algorithm needs.

Load-bearing premise

The load-bearing premise is that the GPU kernel's concurrent insertion routine never writes the same neighbor twice; the paper asserts this duplicate-free property without a proof, and its experiments measure only runtime, never checking outputs against a known-correct reference, so corrupted relation arrays would go unnoticed.

Editorial extensions

If this is right

  • Existing topology-based visualization algorithms can run on GALE unmodified, and the three evaluated ones — critical points, discrete gradient, and Morse-Smale complex — all finish fastest on GALE across the six test meshes.
  • Sequential algorithms benefit too: the output-sensitive Morse-Smale workload, which revisits segments repeatedly, still shows an average 2.7× speedup over the CPU task-parallel baseline because the GPU supplies recomputed relations faster than a dedicated CPU producer thread could.
  • Memory stays close to the CPU-only localized baseline — about 5% more for critical points, 20% more for the discrete gradient, 40% more for Morse-Smale — while using roughly half the memory of a global structure that precomputes all relations.
  • Adding CPU threads helps only up to about 32 consumers, after which total time plateaus; the limiting factor at that point is queueing time, which grows sublinearly, while CPU-GPU communication overhead stays flat.
  • The multi-queue design (one queue and one leader producer per topological relation) is a major contributor in its own right, with the paper reporting an average 2.4× speedup from this design over single-queue alternatives.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If the speedups generalize, the default choice for topology algorithms on unstructured meshes could shift: when a GPU is present, a localized structure with GPU producers would beat a global precomputed structure, except in pipelines where several algorithms share the same relations — a case the paper itself flags as unfavorable.
  • The duplicate-free guarantee of the atomic insertion routine is asserted, not proved, and the reported experiments measure only runtime; a formal proof, or a stress test that compares GALE's outputs against ground truth across many thread counts and segment sizes, would settle whether the correctness claim holds under all interleavings.
  • The batching rule always computes $n_b \cdot t_b / t_s$ future segments per request, independent of what the algorithm will actually touch; a look-ahead policy that predicts access order, for instance from the discrete-gradient path, could shrink the remaining gap on output-sensitive workloads.
  • The queue architecture itself is not specific to topology: any mesh analysis that consumes batched, segment-local queries — neighborhood lookups, interpolation stencils, incidence lists — could adopt the same CPU-consumer/GPU-producer split, provided the query computation is bulk-parallel and confined to a segment.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

2 major / 4 minor

Summary. The paper introduces GALE, a CUDA-based localized data structure for unstructured tetrahedral meshes that offloads the computation of coboundary and adjacency topological relations to the GPU while CPU consumer threads execute the analysis algorithm. A leader producer thread aggregates consumer requests, launches GPU kernels that compute relation arrays for batches of mesh segments, and integrates the results back into the CPU-side data structure. Boundary relations are computed directly by consumers. The authors integrate GALE into the Topology ToolKit and compare it against ACTOPO and TTK Explicit Triangulation when running three TDA algorithms (critical points, discrete gradient, and Morse-Smale complex) on six tetrahedral meshes, reporting up to 2.7× speedup over ACTOPO while maintaining competitive memory usage. They also present a parameter study for the GPU kernel configuration and a detailed breakdown of consumer waiting times.

Significance. If the correctness of the GPU-produced relation arrays is established, GALE is a meaningful contribution: it is, to my knowledge, the first open-source CUDA-based localized data structure that decouples connectivity computation from CPU algorithm execution, and it directly addresses a known limitation of the CPU-bound ACTOPO approach. The integration with TTK means the benefit is demonstrated on real, unmodified algorithms, and the release of source code and raw experimental data is a concrete reproducibility strength. The reported speedups are plausible in direction, and the memory measurements are consistent with the localized-data-structure premise. However, the central performance claim is conditional on an unverified kernel invariant: the duplicate-free construction of relation arrays under concurrent atomic insertions. Since corrupted relation arrays would silently invalidate all downstream algorithm outputs, the experimental claims currently rest on an assumption that needs proof or validation.

major comments (2)
  1. [Section 4.6, Algorithm 2] The claim that the atomicCAS insertion ensures “no duplicates are added” is not established. In the pseudocode, L[σi] is read once into len (line 1), the slot is filled by atomicCAS on M[σi][len++] (line 3), and only afterward is L[σi] updated by atomicAdd (line 6). These two atomic operations target different addresses and are not separated by a fence, so under the CUDA memory model a second thread can observe the incremented L before the slot write to M[σi][0] is visible. It would then start probing at index 1 and could insert the same vertex again. The duplicate check in Algorithm 1 (line 5) is a non-atomic scan and does not close this race. Because the correctness of critical-point counts, discrete-gradient pairings, and Morse-Smale complex outputs depends on duplicate-free relation arrays, the measured speedups are contingent on an invariant that is neither proved nor validated: Section 5 reports no comparison of GALE outputs against a trusted reference. Please provide a correctness argument for the actual kernel (including any memory fences, volatile loads, or alternative synchronization), or modify the insertion scheme so that slot allocation and length update form a single atomic operation, and add an output-validation experiment on at least a subset of the meshes.
  2. [Section 5.1 and Appendix A] The kernel parameters appear to be tuned on the same datasets used for the headline performance comparisons. For example, ts=32 is selected using the Fish dataset in Appendix A.1, and tb=512 is selected using the critical-points algorithm in Appendix A.2, and the same datasets are then used to report the speedups in Section 5.2. Without a held-out validation, or an explicit statement that the parameters were fixed before the benchmark runs, the reported speedups may be optimistically biased and the generalizability of the “guideline” contribution (contribution 3) is unclear. Please state the parameter-selection protocol, and ideally evaluate sensitivity on a dataset not used for tuning.
minor comments (4)
  1. [Algorithm 2] The retry loop in Algorithm 2 has no explicit upper bound: if every slot in the preallocated array M[σi] already contains a value different from σj, the loop will keep incrementing len past the allocated range. The paper should state the maximum expected degree and the allocation strategy, or add an explicit bound.
  2. [Section 4.5] The formula Qr · nb · tb / ts assumes ts divides nb · tb; the paper should specify how rounding is handled when this divisibility does not hold.
  3. [Section 5.2] The runtime comparison is limited to ACTOPO and TTK Explicit Triangulation; since ACTOPO is the authors' own prior work, a brief justification of why it is the appropriate state-of-the-art localized baseline (rather than, e.g., TopoCluster or the Stellar tree) would strengthen the comparison.
  4. [Tables 3 and 4] The GALE initialization times in Table 3 (about 1.5e-4 s) are orders of magnitude smaller than the corresponding ACTOPO values, and the discrete-gradient initialization times in Table 4 vary markedly with consumer count (20.010 s for 6 consumers versus 6.657 s for 36 consumers); a one-sentence explanation of what is measured as initialization time would help the reader interpret these values.

Circularity Check

0 steps flagged · score 2.0 of 10

No circular derivation: GALE's speedups are measured experimental results, with only mild self-reference through the authors' own ACTOPO baseline and same-dataset parameter tuning.

full rationale

The paper's central claims are empirical performance measurements, not derived predictions. GALE is compared against ACTOPO [29], a prior data structure by two of the same authors, and against TTK's Explicit Triangulation; the speedup figures (up to 2.7×) are measured wall-clock and memory values, not quantities obtained by fitting a parameter and then re-predicting it. The self-citation to Liu and Iuricich [29] motivates the task-parallel design but does not serve as an unverified premise on which the new claim rests: ACTOPO is a concrete, implemented baseline whose behavior is measured in the same experimental harness. The parameter study in Appendix A tunes ts, tb, and nb on the same six benchmark meshes used in the headline results, which is a methodological overfitting risk rather than a circular reduction, since no quantity is predicted from the fitted parameters. The unproven duplicate-free invariant of the GPU kernel (Algorithm 2, Section 4.6) is a correctness concern, not a circularity one: even if the relation arrays were corrupted, the performance numbers would still be experimental measurements rather than derivations. No load-bearing step in the paper reduces, by the paper's own equations or by self-citation, to its own inputs. Accordingly, the circularity score is low.

Assumptions & free parameters 4 free parameters · 3 assumptions · 0 invented entities

No new physical or conceptual entities are introduced. The leader and worker producers are software roles within the implementation, not independent postulates.

free parameters (4)
  • ts (GPU threads per segment) = 32
    Selected via parameter study (Appendix A.1) as the best balance between parallelism and synchronization overhead; the reported speedups use this value.
  • tb (GPU threads per block) = 512
    Selected via parameter study (Appendix A.2) as the block size with the best time performance; affects the number of segments precomputed per request.
  • nb (GPU blocks per consumer request) = varies (1 to 32 in study)
    Determines precomputation depth per request; the optimal value depends on dataset and workload, and the paper tunes it to balance kernel launch overhead, memory, and consumer wait time.
  • Maximum vertices per PR octree segment = 100
    Used to subdivide meshes in all experiments; the paper notes the segment size must be tuned to the GPU and mesh, affecting precomputation and GPU memory.
assumptions (3)
  • ad hoc to paper The GPU kernel correctly computes unique topological relations under concurrent atomic insertions (Algorithm 2).
    The paper asserts 'ensuring no duplicates are added to the array' (Section 4.6), but the atomicCAS linear-probe loop can add duplicate entries under certain thread interleavings; no correctness proof or validation of algorithm outputs is provided.
  • domain assumption The PR octree vertex subdivision assigns each vertex to exactly one segment and each simplex to a unique internal segment.
    GALE's mapping of simplices to segments (Section 4.3) relies on the input segmentation being a valid partition; the PR octree is cited from prior work and assumed to provide such a partition.
  • domain assumption CUDA atomic operations on global memory provide the necessary ordering so that the leader producer and worker producers communicate correctly.
    The leader producer relies on kernel completion and memory transfers (Section 4.5), which requires correct synchronization semantics in CUDA; this is a standard framework assumption.

how reviews work

0 comments
Cite this review

Pith. "Pith review of GALE: Leveraging Heterogeneous Systems for Efficient Unstructured Mesh Data Analysis." pith.science (2026). https://pith.science/paper/2DVDUI4O

@misc{pith2026250715230,
  author       = {Pith},
  title        = {Pith review of: GALE: Leveraging Heterogeneous Systems for Efficient Unstructured Mesh Data Analysis},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/2DVDUI4O}},
  note         = {Machine review of arXiv:2507.15230}
}
read the original abstract

Unstructured meshes present challenges in scientific data analysis due to irregular distribution and complex connectivity. Computing and storing connectivity information is a major bottleneck for visualization algorithms, affecting both time and memory performance. Recent task-parallel data structures address this by precomputing connectivity information at runtime while the analysis algorithm executes, effectively hiding computation costs and improving performance. However, existing approaches are CPU-bound, forcing the data structure and analysis algorithm to compete for the same computational resources, limiting potential speedups. To overcome this limitation, we introduce a novel task-parallel approach optimized for heterogeneous CPU-GPU systems. Specifically, we offload the computation of mesh connectivity information to GPU threads, enabling CPU threads to focus on executing the visualization algorithm. Following this paradigm, we propose GALE (GPU-Aided Localized data structurE), the first open-source CUDA-based data structure designed for heterogeneous task parallelism. Experiments on two 20-core CPUs and an NVIDIA V100 GPU show that GALE achieves up to 2.7x speedup over state-of-the-art localized data structures while maintaining memory efficiency.

Figures

Figures reproduced from arXiv: 2507.15230 by the authors.

Figure 2
Figure 2. (a) Workflow of the classic approach with one thread. (b) Workflow [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 1
Figure 1. (a) An example of a simplicial complex with an input scalar field [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 4
Figure 4. The input tetrahedral mesh contains the vertex list [PITH_FULL_IMAGE:figures/full_fig_p004_4.png] view at source ↗
Figures from the paper (13 more)
Figure 3
Figure 3. Figure 3: Pipeline of the proposed heterogeneous computation model [PITH_FULL_IMAGE:figures/full_fig_p004_3.png]
Figure 5
Figure 5. Figure 5: Arrays created during the initialization stage include the edge [PITH_FULL_IMAGE:figures/full_fig_p005_5.png]
Figure 6
Figure 6. Figure 6: The leader producer assigns workload to worker producers [PITH_FULL_IMAGE:figures/full_fig_p005_6.png]
Figure 7
Figure 7. Figure 7: Total time and main memory usage of running critical points [PITH_FULL_IMAGE:figures/full_fig_p007_7.png]
Figure 8
Figure 8. Figure 8: Total time and main memory usage of running discrete gradient [PITH_FULL_IMAGE:figures/full_fig_p007_8.png]
Figure 9
Figure 9. Figure 9: Total time and main memory usage of running MS complex [PITH_FULL_IMAGE:figures/full_fig_p008_9.png]
Figure 10
Figure 10. Figure 10: Breakdown of the total waiting time for the consumer thread [PITH_FULL_IMAGE:figures/full_fig_p008_10.png]
Figure 12
Figure 12. Figure 12: Time and main memory usage when running critical points [PITH_FULL_IMAGE:figures/full_fig_p012_12.png]
Figure 13
Figure 13. Figure 13: Time and main memory usage when running critical points [PITH_FULL_IMAGE:figures/full_fig_p013_13.png]
Figure 14
Figure 14. Figure 14: Waiting time distribution when running the critical points algo [PITH_FULL_IMAGE:figures/full_fig_p013_14.png]
Figure 15
Figure 15. Figure 15: Waiting time distribution when running the critical points algorithm with 32 and 40 consumers [PITH_FULL_IMAGE:figures/full_fig_p014_15.png]
Figure 16
Figure 16. Figure 16: Waiting time distribution when running the discrete gradient algorithm with 8, 16, 24, and 32 consumers [PITH_FULL_IMAGE:figures/full_fig_p014_16.png]
Figure 17
Figure 17. Figure 17: Waiting time distribution when running the discrete gradient [PITH_FULL_IMAGE:figures/full_fig_p015_17.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

59 extracted references · 30 canonical work pages

  1. [1]

    T. F. Banchoff. Critical Points and Curvature for Embedded Polyhedral Surfaces. The American Mathematical Monthly , 77(5):475–485, Apr

    work page

  2. [2]

    X. Bao, N. Karthikeyan, U. D. Schiller, and F. Iuricich. Application- oriented Analysis of Material Interface Reconstruction Algorithms in Time-varying Bijel Simulations. In Proceedings of the 24th EuroVis - Short Papers. The Eurographics Association, Rome, Italy, June 2022. doi: 10.2312/evs.20221104 1

    work page doi:10.2312/evs.20221104 2022

  3. [3]

    Bhatia, A

    H. Bhatia, A. Gyulassy, V . Lordi, J. Pask, V . Pascucci, and P.-T. Bre- mer. TopoMS: Comprehensive topological exploration for molecular and condensed-matter systems: Comprehensive Topological Exploration for Molecular and Condensed-Matter Systems. Journal of Computational Chemistry, 39:936–952, Mar. 2018. doi: 10.1002/jcc.25181 3

    doi:10.1002/jcc.25181 2018

  4. [4]

    Boissonnat and C

    J.-D. Boissonnat and C. Maria. The Simplex Tree: an Efficient Data Structure for General Simplicial Complexes. Algorithmica, 70(3):406– 427, May 2014. doi: 10.1007/s00453-014-9887-3 2

    work page doi:10.1007/s00453-014-9887-3 2014

  5. [5]

    Canino and L

    D. Canino and L. De Floriani. Representing Simplicial Complexes with Mangroves. In Proceedings of the 22nd International Meshing Roundtable, pp. 465–483. Springer, Orlando, FL, USA, Oct. 2014. doi: 10.1007/978-3 -319-02335-9_26 2

    doi:10.1007/978-3 2014

  6. [6]

    Canino, L

    D. Canino, L. De Floriani, and K. Weiss. IA ∗: An adjacency-based representation for non-manifold simplicial shapes in arbitrary dimensions. Computers & Graphics, 35(3):747–753, June 2011. doi: 10.1016/j.cag. 2011.03.009 2, 3

    work page doi:10.1016/j.cag 2011

  7. [7]

    H. A. Carr, O. Rübel, and G. H. Weber. Distributed Hierarchical Contour Trees. In Proceedings of the IEEE 12th Symposium on Large Data Analysis and Visualization (LDAV), pp. 1–10. IEEE, Oklahoma City, OK, USA, Oct. 2022. doi: 10.1109/LDA V57265.2022.9966394 3

    arXiv 2022

  8. [8]

    H. A. Carr, G. H. Weber, C. M. Sewell, and J. P. Ahrens. Parallel Peak Pruning for Scalable SMP Contour Tree Computation. In Proceedings of the IEEE 6th Symposium on Large Data Analysis and Visualization (LDAV), pp. 75–84. IEEE, Baltimore, MD, USA, Oct. 2016. doi: 10. 1109/LDA V.2016.7874312 3

    work page arXiv 2016

Show all 59 references
  1. [9]

    H. A. Carr, G. H. Weber, C. M. Sewell, O. Rübel, P. Fasel, and J. P. Ahrens. Scalable Contour Tree Computation by Data Parallel Peak Pruning. IEEE Transactions on Visualization and Computer Graphics, 27(4):2437–2454, Apr. 2021. doi: 10.1109/TVCG.2019.2948616 3

    2021

  2. [10]

    A. L. Codd and L. Gross. Three-dimensional inversion for sparse potential data using first-order system least squares with application to gravity anomalies in Western Queensland. Geophysical Journal International, 227(3):2095–2120, Aug. 2021. doi: 10.1093/gji/ggab323 1

    2021 doi

  3. [11]

    Dai and M

    A. Dai and M. Nießner. Scan2Mesh: From Unstructured Range Scans to 3D Meshes. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR) , pp. 5569–5578. IEEE, Long Beach, CA, USA, June 2019. doi: 10.1109/CVPR.2019.00572 1

    2019

  4. [12]

    De Floriani, U

    L. De Floriani, U. Fugacci, F. Iuricich, and P. Magillo. Morse Complexes for Shape Segmentation and Homological Analysis: Discrete Models and Algorithms. Computer Graphics Forum, 34(2):761–785, June 2015. doi: 10.1111/cgf.12596 3

    2015 doi

  5. [13]

    DiCarlo, A

    A. DiCarlo, A. Paoluzzi, and V . Shapiro. Linear algebraic representation for topological structures. Computer-Aided Design, 46:269–274, Jan

  6. [14]

    Edelsbrunner

    H. Edelsbrunner. Algorithms in Combinatorial Geometry, vol. 10. Springer Verlag, July 1987. doi: 10.1007/978-3-642-61568-9 2

    1987 doi

  7. [15]

    Fellegara, K

    R. Fellegara, K. Weiss, and L. De Floriani. The Stellar decomposition: A compact representation for simplicial complexes and beyond. Computers & Graphics, 98:322–343, Aug. 2021. doi: 10.1016/j.cag.2021.05.002 1, 3, 4, 5

    2021 doi

  8. [16]

    R. Forman. A User’s Guide To Discrete Morse Theory. Séminaire Lotharingien de Combinatoire, 48:B48c, 35 p., Dec. 2001. 7

    2001

  9. [17]

    Gueunet, P

    C. Gueunet, P. Fortin, J. Jomier, and J. Tierny. Contour Forests: Fast Multi-threaded Augmented Contour Trees. In Proceedings of the IEEE 6th Symposium on Large Data Analysis and Visualization (LDAV) , pp. 85–92. IEEE, Baltimore, MD, USA, Oct. 2016. doi: 10.1109/LDA V.2016. 7874333 3

    2016 doi

  10. [18]

    Gueunet, P

    C. Gueunet, P. Fortin, J. Jomier, and J. Tierny. Task-Based Augmented Contour Trees with Fibonacci Heaps. IEEE Transactions on Parallel and Distributed Systems, 30(8):1889–1905, Aug. 2019. doi: 10.1109/TPDS. 2019.2898436 3

    1905

  11. [19]

    Gyulassy, P.-T

    A. Gyulassy, P.-T. Bremer, B. Hamann, and V . Pascucci. A Practical Approach to Morse-Smale Complex Computation: Scalability and Gen- erality. IEEE Transactions on Visualization and Computer Graphics , 14(6):1619–1626, Nov. 2008. doi: 10.1109/TVCG.2008.110 3

    2008 doi

  12. [20]

    Gyulassy, P.-T

    A. Gyulassy, P.-T. Bremer, and V . Pascucci. Computing Morse-Smale Complexes with Accurate Geometry. IEEE Transactions on Visualization and Computer Graphics, 18(12):2014–2022, Dec. 2012. doi: 10.1109/ TVCG.2012.209 3

    2014

  13. [21]

    Gyulassy, P.-T

    A. Gyulassy, P.-T. Bremer, and V . Pascucci. Shared-Memory Parallel Computation of Morse-Smale Complexes with Improved Accuracy. IEEE Transactions on Visualization and Computer Graphics, 25(1):1183–1192, Jan. 2019. doi: 10.1109/TVCG.2018.2864848 3

    2019

  14. [22]

    Gyulassy, D

    A. Gyulassy, D. Günther, J. A. Levine, J. Tierny, and V . Pascucci. Conform- ing Morse-Smale Complexes. IEEE Transactions on Visualization and Computer Graphics, 20(12):2595–2603, Dec. 2014. doi: 10.1109/TVCG. 2014.2346434 3

    2014

  15. [23]

    Gyulassy, V

    A. Gyulassy, V . Pascucci, T. Peterka, and R. Ross. The Parallel Com- putation of Morse-Smale Complexes. In Proceedings of the IEEE 26th International Parallel and Distributed Processing Symposium, pp. 484–

  16. [24]

    Heine, H

    C. Heine, H. Leitte, M. Hlawitschka, F. Iuricich, L. De Floriani, G. Scheuermann, H. Hagen, and C. Garth. A Survey of Topology-Based Methods in Visualization. Computer Graphics Forum, 35(3):643–667, June 2016. doi: 10.1111/cgf.12933 3

    2016 doi

  17. [25]

    Heinecke, A

    A. Heinecke, A. Breuer, S. Rettenberger, M. Bader, A.-A. Gabriel, C. Pel- ties, A. Bode, W. Barth, X.-K. Liao, K. Vaidyanathan, M. Smelyanskiy, and P. Dubey. Petascale High Order Dynamic Rupture Earthquake Simulations on Heterogeneous Supercomputers. In Proceedings of the Inte...

    2014

  18. [26]

    Kremer, D

    M. Kremer, D. Bommes, and L. Kobbelt. OpenV olumeMesh - A Versatile Index-Based Data Structure for 3D Polytopal Complexes. In X. Jiao and J.- C. Weill, eds., Proceedings of the 21st International Meshing Roundtable, pp. 531–548. Springer, San Jose, CA, USA, Oct. 2012. doi: 10....

    2012 doi

  19. [27]

    C. Lawson. Software for C1 Surface Interpolation. In J. R. Rice, ed., Mathematical Software, pp. 161–194. Academic Press, Mar. 1977. doi: 10 .1016/B978-0-12-587260-7.50011-X 2

    1977

  20. [28]

    C.-H. Lin, J. Gao, L. Tang, T. Takikawa, X. Zeng, X. Huang, K. Kreis, S. Fidler, M.-Y . Liu, and T.-Y . Lin. Magic3D: High-Resolution Text-to-3D Content Creation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 300–309. IEEE, Vancou...

    2023

  21. [29]

    Liu and F

    G. Liu and F. Iuricich. A Task-Parallel Approach for Localized Topological Data Structures. IEEE Transactions on Visualization and Computer Graph- ics, 30(1):1271–1281, Jan. 2024. doi: 10.1109/TVCG.2023.3327182 1, 2, 3, 7 10 © 2025 IEEE. This is the author’s version of the art...

    2024

  22. [30]

    G. Liu, F. Iuricich, R. Fellegara, and L. De Floriani. TopoCluster: A Local- ized Data Structure for Topology-Based Visualization. IEEE Transactions on Visualization and Computer Graphics, 29(2):1506–1517, Feb. 2023. doi: 10.1109/TVCG.2021.3121229 1, 3, 5

    2023

  23. [31]

    A. H. Mahmoud, S. D. Porumbescu, and J. D. Owens. RXMesh: A GPU Mesh Data Structure. ACM Transactions on Graphics, 40(4):1–16, Aug

  24. [32]

    Michel, R

    O. Michel, R. Bar-On, R. Liu, S. Benaim, and R. Hanocka. Text2Mesh: Text-Driven Neural Stylization for Meshes. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 13492–13502. IEEE, New Orleans, LA, USA, June 2022. doi: 10.48550/arX...

    2022 doi arXiv

  25. [33]

    J. Milnor. Morse Theory. The American Mathematical Monthly, 71:936– 936, Oct. 1964. doi: 10.2307/2312441 7

    1964 doi

  26. [34]

    G. M. Nielson. Tools for Triangulation and Tetrahedrizations and Con- structing Functions Defined over Them. In G. M. Nielson, H. Hagen, and H. Müller, eds., Scientific Visualization: Overviews, Methodologies and Techniques, pp. 429–525. IEEE Computer Society, Silver Spring, M...

    1994

  27. [35]

    Paoluzzi, F

    A. Paoluzzi, F. Bernardini, C. Cattani, and V . Ferrucci. Dimension- Independent Modeling with Simplicial Complexes. ACM Transactions on Graphics (TOG), 12(1):56–102, Jan. 1993. doi: 10.1145/169728.169719 2

    1993

  28. [36]

    Peterka, R

    T. Peterka, R. Ross, A. Gyulassy, V . Pascucci, W. Kendall, H.-W. Shen, T.-Y . Lee, and A. Chaudhuri. Scalable parallel building blocks for custom data analysis. In Proceedings of the IEEE Symposium on Large Data Analysis and Visualization (LDAV), pp. 105–112. IEEE, Providence...

    2011

  29. [37]

    Robins, P

    V . Robins, P. J. Wood, and A. P. Sheppard. Theory and Algorithms for Constructing Discrete Morse Complexes from Grayscale Digital Im- ages. IEEE Transactions on Pattern Analysis and Machine Intelligence, 33(8):1646–1658, Aug. 2011. doi: 10.1109/TPAMI.2011.95 2, 3, 7

    2011 doi

  30. [38]

    H. Samet. Foundations of Multidimensional and Metric Data Structures. Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, Nov. 2005. 4, 6

    2005

  31. [39]

    Sathar, M

    S. Sathar, M. L. Trew, and L. K. Cheng. Tissue specific simulations of interstitial cells of cajal networks using unstructured meshes. In Proceed- ings of the 37th Annual International Conference of the IEEE Engineering in Medicine and Biology Society (EMBC), pp. 8062–8065. IE...

    2015

  32. [40]

    Shivashankar and V

    N. Shivashankar and V . Natarajan. Parallel Computation of 3D Morse- Smale Complexes. Computer Graphics Forum, 31(3pt1):965–974, 10 pages, June 2012. doi: 10.1111/j.1467-8659.2012.03089.x 3

    2012

  33. [41]

    Shulga, O

    D. Shulga, O. Morozov, and P. Hunziker. A Tensor B-Spline Approach for Solving the Diffusion PDE With Application to Optical Diffusion Tomography. IEEE Transactions on Medical Imaging, 36(4):972–982, Apr. 2017. doi: 10.1109/TMI.2016.2641500 1

    2017

  34. [42]

    Simonis and T

    H. Simonis and T. Cornelissens. Modelling Producer/Consumer Con- straints. In G. Goos, J. Hartmanis, J. Leeuwen, U. Montanari, and F. Rossi, eds., Principles and Practice of Constraint Programming, vol. 976, pp. 449–462. Springer, Berlin, Heidelberg, June 1995. doi: 10.1007/3-...

    1995 doi

  35. [43]

    Subhash, K

    V . Subhash, K. Pandey, and V . Natarajan. GPU Parallel Computation of Morse-Smale Complexes. In Proceedings of the IEEE Visualization Conference (VIS), pp. 36–40. IEEE, Salt Lake City, UT, USA, Oct. 2020. doi: 10.1109/VIS47514.2020.00014 3

    2020

  36. [44]

    Tierny, G

    J. Tierny, G. Favelier, J. A. Levine, C. Gueunet, and M. Michaux. The Topology ToolKit. IEEE Transactions on Visualization and Computer Graphics, 24(1):832–842, Jan. 2018. doi: 10.1109/TVCG.2017.2743938 2, 3, 4, 5, 6, 7, 9

    2018

  37. [45]

    I. Wald, N. Morrical, and S. Zellmann. A Memory Efficient Encoding for Ray Tracing Large Unstructured Data.IEEE Transactions on Visualization and Computer Graphics, 28(1):583–592, Jan. 2022. doi: 10.1109/TVCG. 2021.3114869 2

    2022

  38. [46]

    N. Wang, Y . Zhang, Z. Li, Y . Fu, W. Liu, and Y .-G. Jiang. Pixel2Mesh: Generating 3D Mesh Models from Single RGB Images. In Proceedings of the European conference on computer vision (ECCV), pp. 52–67. Springer, Munich, Germany, Sept. 2018. doi: 10.1007/978-3-030-01252-6_4 1

    2018 doi

  39. [47]

    Weiss, L

    K. Weiss, L. De Floriani, R. Fellegara, and M. Velloso. The PR-star octree: a spatio-topological data structure for tetrahedral meshes. In Proceedings of the 19th ACM SIGSPATIAL International Conference on Advances in Geographic Information Systems, pp. 92–101. ACM, Chicago, I...

    2011

  40. [48]

    X. Xu, F. Iuricich, K. Calders, J. Armston, and L. De Floriani. Topology- based individual tree segmentation for automated processing of terrestrial laser scanning point clouds. International Journal of Applied Earth Ob- servation and Geoinformation, 116:103145, Feb. 2023. doi...

    2023

  41. [49]

    L. Yan, T. B. Masood, R. Sridharamurthy, F. Rasheed, V . Natarajan, I. Hotz, and B. Wang. Scalar Field Comparison with Topological Descriptors: Prop- erties and Applications for Scientific Visualization. Computer Graphics Forum, 40(3):599–633, June 2021. doi: 10.1111/cgf.14331 3

    2021 doi

  42. [50]

    C. Yu, Y . Xu, Y . Kuang, Y . Hu, and T. Liu. MeshTaichi: A Compiler for Efficient Mesh-Based Operations. ACM Transactions on Graphics, 41(6), article no. 252, 17 pages, Nov. 2022. doi: 10.1145/3550454.3555430 1

    2022

  43. [51]

    Zayer, M

    R. Zayer, M. Steinberger, and H.-P. Seidel. A GPU-Adapted Structure for Unstructured Grids. Computer Graphics Forum, 36(2):495–507, May

  44. [52]

    X. Zhao, X. Yu, M. Qiu, F. Qing, and S. Zou. An arbitrary Lagrangian- Eulerian RKDG method for multi-material flows on adaptive unstructured meshes. Computers & Fluids, 207:104589, July 2020. doi: 10.1016/j. compfluid.2020.104589 1

    2020

  45. [53]

    ¸ Sahıstan, S

    A. ¸ Sahıstan, S. Demirci, N. Morrical, S. Zellmann, A. Aman, I. Wald, and U. Güdükbay. Ray-traced Shell Traversal of Tetrahedral Meshes for Direct V olume Visualization. InProceedings of the IEEE Visualization Conference (VIS), pp. 91–95. IEEE, New Orleans, LA, USA, Oct. 2021...

    2021

  46. [59]

    In general, the execution time decreases first and then increases as the number of blocks grows

    Figure 13 shows the bar charts of time and memory usage. In general, the execution time decreases first and then increases as the number of blocks grows. The main reason is that using more blocks can precompute more mesh segments to reduce the waiting time of consumer threads....

    2025

  47. [495]

    doi: 10.1109/IPDPS.2012.52 3

    IEEE, Shanghai, China, May 2012. doi: 10.1109/IPDPS.2012.52 3

    2012 doi

  48. [1970]

    doi: 10.1080/00029890.1970.11992523 3

    1970

  49. [2014]

    doi: 10.1016/j.cad.2013.08.044 3

    2013 doi

  50. [2017]

    doi: 10.1111/cgf.13144 3

    doi

  51. [2021]

    doi: 10.1145/3450626.3459748 3

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.