Search for: All records

This study explores the role of gas flow dynamics in the fragmentation of thin liquid sheets using three-dimensional numerical simulations. A thin liquid sheet with a thickness of 25 μm is subjected to high-velocity co-flowing gas streams characterized by three distinct gas Reynolds numbers, namely, Reg=300,500, and 1000. Simulations show that the breakup behavior of the sheet is governed by the vortical structures formed in the gas flow, which range from oblique vortex shedding at lower Reg to rib-like vortical patterns at higher Reg. The gas-induced instabilities impose transverse and longitudinal oscillations on the liquid sheet, which govern the locations of hole formation, the development of ligaments, and ultimately the resulting droplet size distribution. For Reg=300, breakup occurs via rim instability and the end-pinching or Rayleigh–Plateau-type instability of liquid fingers, whereas for Reg=500 and 1000, sheet rupture through hole formation and collision dominates. A manifold death (MD) algorithm is used to enforce breakup at a grid-independent critical film thickness, improving robustness against numerical artifacts. Droplet size distributions obtained with and without the MD algorithm confirm that the dominant droplet size remains unchanged, while the formation of small, potentially spurious droplets is suppressed. The resulting distributions align more closely with a lognormal model, consistent with the presence of multiple breakup mechanisms. This work provides new insight into the coupling between gas-phase instabilities and liquid fragmentation, offering a pathway to more accurate predictive models for air-blast atomization processes. 

We propose a GPU fine-grained load-balancing abstraction that decouples load balancing from work processing and aims to support both static and dynamic schedules with a programmable interface to implement new load-balancing schedules. Prior to our work, the only way to unleash the GPU’s potential on irregular problems has been to workload- balance through application-specific, tightly coupled load- balancing techniques. With our open-source framework for load-balancing, we hope to improve programmers’ productivity when developing irregular-parallel algorithms on the GPU, and also improve the overall performance characteristics for such applications by allowing a quick path to experimentation with a variety of existing load-balancing techniques. Consequently, we also hope that by separating the concerns of load-balancing from work processing within our abstraction, managing and extending existing code to future architectures becomes easier. 

We identify the graph data structure, frontiers, operators, an iterative loop structure, and convergence conditions as essential components of graph analytics systems based on the native-graph approach. Using these essential components, we propose an abstraction that captures all the significant programming models within graph analytics, such as bulk-synchronous, asynchronous, shared-memory, message-passing, and push vs. pull traversals. Finally, we demonstrate the power of our abstraction with an elegant modern C++ implementation of single-source shortest path and its required components. 

We design and implement parallel graph coloring algorithms on the GPU using two different abstractions—one datacentric (Gunrock), the other linear-algebra-based (GraphBLAS). We analyze the impact of variations of a baseline independent-set algorithm on quality and runtime. We study how optimizations such as hashing, avoiding atomics, and a max-min heuristic affect performance. Our Gunrock graph coloring implementation has a peak 2x speed-up, a geomean speed-up of 1.3x and produces 1.6x more colors over previous hardwired state-of-theart implementations on real-world datasets. Our GraphBLAS implementation of Luby’s algorithm produces 1.9x fewer colors than the previous state-of-the-art parallel implementation at the cost of 3x extra runtime, and 1.014x fewer colors than a greedy, sequential algorithm with a geomean speed-up of 2.6x. 

We design and implement parallel graph coloring algorithms on the GPU using two different abstractions—one data-centric (Gunrock), the other linear-algebra-based (GraphBLAS). We analyze the impact of variations of a baseline independent-set algorithm on quality and runtime. We study how optimizations such as hashing, avoiding atomics, and a max-min heuristic affect performance. Our Gunrock graph coloring implementation has a peak 2x speed-up, a geomean speed-up of 1.3x and produces 1.6x more colors over previous hardwired state-of-the-art implementations on real-world datasets. Our GraphBLAS implementation of Luby's algorithm produces 1.9x fewer colors than the previous state-of-the-art parallel implementation at the cost of 3x extra runtime, and 1.014x fewer colors than a greedy, sequential algorithm with a geomean speed-up of 2.6x. 

Recent node-level GPU accelerated graph processing frameworks have separately chosen synchronous and asynchronous architectures. Which is better under which circumstances, and why? We focus on Gunrock (a synchronous framework) vs. Groute (an asynchronous framework) with 3 primitives on 3 different datasets. We identify load balance, kernel count, and communication latency and bandwidth as quantities of particular interest.