GPolylla: Fully GPU-accelerated polygonal mesh generator

TL;DR

This work tackles efficient polygonal mesh generation on GPUs by evolving Polylla into a fully GPU-accelerated tool, GPolylla, that converts an input triangulation $τ=(V,E)$ into a polygonal mesh $τ'=(V,E')$ via terminal-edge regions and the Longest-Edge Propagation Path ($Lepp$). It employs a half-edge (DCEL) representation on the GPU and performs in-place topology changes by updating next/prev pointers, avoiding dynamic memory allocation. The approach comprises a data-parallel label-traversal-repair pipeline across six CUDA kernels, with seed management and a tensor-core-accelerated scan to produce a final polygonal mesh entirely on the GPU. Empirical results show substantial speedups relative to CPU sequential implementations (up to ×83.2 including copy costs, ×746.8 excluding copy) and demonstrate scalability to large meshes, highlighting GPU data-transfer costs as a major factor and suggesting further optimizations using compact data layouts. The findings indicate that fully GPU-accelerated polygonal mesh generation is viable and practical for high-resolution simulations and VEM workflows.

Abstract

This work presents a fully GPU-accelerated algorithm for the polygonal mesh generator known as Polylla. Polylla is a tri-to-polygon mesh generator, which benefits from the half-edge data structure to manage any polygonal shape. The proposed parallel algorithm introduces a novel approach to modify triangulations to get polygonal meshes using the half-edge data structure in parallel on the GPU. By changing the adjacency values of each half-edge, the algorithm accomplish to unlink half-edges that are not used in the new polygonal mesh without the need neither removing nor allocating new memory in the GPU. The experimental results show a speedup, reaching up to $\times 83.2$ when compared to the CPU sequential implementation. Additionally, the speedup is $\times 746.8$ when the cost of copying the data structure from the host device and back is not included.

Figures (12)

• Figure 1: Polygonal mesh of a circular saw generated using Polylla mesh generator.
• Figure 2: Example of generating a Polylla mesh from an initial triangulation: (a) Output of the label phase to generate terminal-edge regions. Black lines are frontier edges, dotted gray lines are internal edges, and terminal edges are red dashed lines. Terminal edges can be inside or at the boundary of the geometric domain, so dashed lines are border terminal edges, and dotted dashed lines are internal terminal edges. barrier tips are green squared vertices and seed triangles are marked with a blue cross. (b) Traversal phase example: Arrows inside terminal regions show the paths of the algorithm during the conversion from a terminal-edge region to a polygon. The path starts at a triangle labeled as a seed triangle. Each terminal-edge region has only one seed triangle. (c) Example of a non-simple polygon split using interior edges with barrier tips as endpoints. To split the polygon, the algorithm labels the middle interior edges incident to the barrier tips as frontier edges, which are then stored along with cross-labeled triangles as seed triangles. The algorithm repeats the traversal phase using a new seed triangle but avoids generating the same polygon again. (d) Final Polylla mesh. Source salinas2023generation
• Figure 3: (a) Polygonal mesh (b) Representation of the mesh using half-edge data structure (b) Example of queries for a half-edge $e$.
• Figure 4: Vertex and Half-edge records
• Figure 5: (a) A terminal-edge region formed by two adjacent triangles represented as the half-edge data structure. (b) The terminal-edge is dereferenced by changing the values of the next and prev of $he_i$ and $he_j$. (c) Final result of the edge elimination, a square.

Theorems & Definitions (3)

• Definition 1
• Definition 2
• Definition 3