In high-performance computing (HPC), in situ analysis and visualization avoid costly I/O by extracting insight during the simulation run. When these tasks execute on the same GPUs that drive the simulation, resource contention can degrade performance. We propose an asynchronous framework that offloads visualization to idle CPU cores and overlaps in situ work with simulation execution. The framework uses ASCENT for efficient data movement and rendering and applies core pinning. Evaluated with NekRS on Polaris and JUWELS Booster, it reduced end-to-end runtime by 21-40% for slice-based visualizations compared to inline GPU instrumentation. Slice outputs incurred little overhead and overlapped cleanly with the simulation. Heavier filters like isovolumes, multilevel contours, and volume rendering were "free" (i.e., visualization time was encapsulated by simulation time) only at lower node counts, consistent with a CPU-budget model: filter cost and output cadence must fit the cores available per node.
Color blending is a widely used technique in mosaic or panorama image processing, particularly for seamlessly combining images with varying lighting or weather conditions. One key application is in aerial image mosaics, where seams often arise between images captured by aircraft. Blending large-scale mosaics, however, typically requires access to global image information, resulting in high memory demands. Prior work has addressed this challenge either through interactive local blending or by leveraging high-performance computing (HPC) systems with distributed memory.In this work, we present an out-of-core blending approach that processes large mosaics tile by tile using an iterative Poisson solver. Our method leverages a downsampled global mosaic to guide local blending, eliminating the need to load the full-resolution dataset into memory. We further introduce two adaptive execution strategies that vary the number of solver iterations per tile, improving both efficiency and quality. We demonstrate our approach using large orthomosaic datasets from the National Ecological Observatory Network (NEON), and implement the pipeline using the SYCL programming model for cross-platform portability.
We present a visual analytics system to increase proposal approval likelihood in Proof-of-Stake(PoS) blockchain governance. The proposed system introduces the Contextual Alliance Index(CAI), a similarity metric reflecting contextual information based on proposal voting data. Through heatmaps and bubble heap graphs, users can explore alliances among validators and support comparison and prioritization of persuadable validators. Furthermore, a case study illustrates an analytical process for understanding voting patterns for each proposal, and for identifying alliances and the prioritization of persuadable validators when drafting new proposals. This study is expected to contribute to the in-depth analysis of proposal patterns and the development of effective proposal strategies by identifying validator alliances in PoS blockchain governance.
We present two algorithms for building bricks over AMR cells on the GPU. Both algorithms focus on construction performance and produce output that allows for efficient cell location using NVIDIA ray tracing cores. In an effort to determine potential trade-offs between construction and sampling performance, we evaluate these algorithms on rendering methods common in scientific visualization.
We present a novel use of error-bounded lossy compression to accelerate distributed parallel volume rendering, which involves blending many semi-transparent images rendered by distributed processes, a procedure known as parallel image compositing. Specifically, we improve the widely adopted binary-swap algorithm by compressing intermediate images with strict pixel-wise error bounds. We propose a per-pixel error-bound model tailored to each communication request in the binary-swap algorithm to control the compositing error. We derive a per-round error bound based on the color and opacity of each intermediate pixel during compositing. Our algorithm also uses a dynamic strategy that balances compression and communication cost, deciding whether to compress based on network latency, bandwidth, and compressor performance. Our method significantly improves the frame rate for in situ rendering, demonstrating notable performance improvements in frame rate. We evaluate our algorithm through an end-to-end GPU-based parallel volume rendering pipeline using a GPU-accelerated renderer and compressor, integrated with CUDA-aware MPI. We demonstrate scalability with up to 512 GPUs on the Perlmutter supercomputer.
