CCL Participated in the 18th ND CSE Annual Poster Session

On February 26, 2026, we participated in the 18th ND CSE Annual Poster Session. It was a good chance for the lab to share what we’ve been working on. Here’s a quick rundown of what everyone presented.

Alan Malta presented his work on large-scale HEP workflows. CMS and other LHC experiments run workflows across the Worldwide LHC Computing Grid, and the way you group and compose tasks can make a big difference in throughput and resource use. Alan built DAGFlowSim to explore the trade-offs between different workflow constructions (TaskChain vs StepChain and everything in between) and figure out which compositions work best for event throughput, CPU utilization, and network efficiency.

Barry Sly-Delgado talked about restructuring workflows with algebraic labels. The idea is that if you can characterize operations by properties like commutativity and associativity, you can restructure the DAG for a better topology, with more parallelism, less overhead, and better fault tolerance. He integrated this with Dask and TaskVine and showed improvements on real HEP apps like RsTriPhoton, DVS, and tBar.

Colin Thomas presented Contour, a tool that traces the I/O of a running application and turns it into an “execution contract.” Scientific apps often have implicit file dependencies that are hard to see from the script alone. Contour captures what gets read and written, then uses that to generate workflows for Makeflow so you can reproduce, distribute, and scale the app more reliably.

Jin Zhou presented DAGVine, which tackles a bottleneck we’ve been hitting: when you have lots of small tasks, serialization and dispatch overhead can dominate. DAGVine pre-compiles the whole dependency graph and installs it on workers, so at runtime you just send lightweight task references instead of shipping Python objects every time. In benchmarks it gets up to 82× higher throughput than DaskVine.

Laxminarayana Vadnala (Lax) presented SADE-SIM, a simulation platform for validating city-scale multi-drone operations. It combines physics simulation with photorealistic visualization so you can test autonomous UAV missions in realistic urban environments. His case study ran 32 heterogeneous drones over downtown Chicago with dynamic airspace policies. Only public-safety drones could enter a restricted zone, while others were deflected at the boundary.

Ryan Hartung presented xGFabric, which connects sensors in the field with HPC facilities over 5G/6G networks for real-time digital agriculture. Sensors at UNL collect weather data, which flows over a private 5G cell to a base station, then to UCSB, and finally triggers an OpenFOAM simulation on an HPC cluster. The whole pipeline runs in near real time so you can steer the simulation based on what’s happening in the field.

Md Saiful Islam presented his work on portable notebook workflows. Data-intensive notebooks are hard to move between HPC sites because of different storage, paths, and staging logic. Saiful’s Backpack abstraction uses declarative data specs and fingerprinting to capture what’s needed and run consistently across ND CRC, Anvil, and Stampede3. He demonstrated it on HEP analysis and image convolution workloads.

Thanh Son Phung presented StickyInvoc, which rethinks how we run LLM inference at scale. The problem is that loading a model on a GPU is expensive, and on opportunistic clusters you might get preempted and have to reload over and over. StickyInvoc lets workers keep model state across tasks so subsequent inferences reuse it. In a claim verification workflow it hit 3.6× speedup, and scaled to 186 opportunistic GPU tasks in about 13 minutes.

It was a great day to catch up with colleagues and share what we’ve been building. Thanks to everyone who stopped by our posters, and we look forward to the next one.