multi-topic, publish from gh-pages branch

site/content/cloud-edge/digests/ATC-2024/index.md

@@ -0,0 +1,108 @@
+---
+title: ATC 2024 Digest
+venue: ATC
+year: 2024
+date: '2024-01-01'
+tags: []
+paper_count: 12
+draft: false
+---
+
+12 papers selected.
+
+---
+
+### FetchBPF: Customizable Prefetching Policies in Linux with eBPF
+
+*Xuechun Cao, Shaurya Patel, Soo-Yee Lim, Xueyuan Han *et al.**
+
+**TL;DR** — Extends eBPF into the page-fault / prefetch path, giving user-space programs a safe, low-overhead hook to install custom hardware-prefetch policies without kernel modifications.
+
+---
+
+### Fast (Trapless) Kernel Probes Everywhere
+
+*Jinghao Jia, Michael V. Le, Salman Ahmed 0001, Dan Williams 0001 *et al.**
+
+**TL;DR** — Eliminates the trap-based overhead of kprobes by using binary rewriting to instrument kernel functions at near-zero cost, enabling always-on production tracing.
+
+---
+
+### FBMM: Making Memory Management Extensible With Filesystems
+
+*Bijan Tabatabai, James Christopher Sorenson III, Michael M. Swift*
+
+**TL;DR** — Proposes delegating Linux virtual-memory management to filesystem drivers via a clean abstraction layer, opening the OS memory subsystem to the same extensibility that filesystems enjoy.
+
+---
+
+### Limitations and Opportunities of Modern Hardware Isolation Mechanisms
+
+*Xiangdong Chen, Zhaofeng Li 0004, Tirth Jain, Vikram Narayanan *et al.**
+
+**TL;DR** — Empirically evaluates Intel MPK, RISC-V sPMP, and related primitives and shows that their performance and safety properties diverge sharply from vendor claims, motivating a fresh look at hardware-assisted compartmentalization.
+
+---
+
+### FastCommit: resource-efficient, performant and cost-effective file system journaling
+
+*Harshad Shirwadkar, Saurabh Kadekodi, Theodore Y. Ts'o*
+
+**TL;DR** — Redesigns ext4 journal commits to write only changed metadata deltas rather than full blocks, slashing journaling overhead while preserving crash consistency — and is already deployed in the Linux kernel.
+
+---
+
+### ZMS: Zone Abstraction for Mobile Flash Storage
+
+*Joo Young Hwang, Seokhwan Kim, Daejun Park 0002, Yong-Gil Song *et al.**
+
+**TL;DR** — Introduces a zone-based abstraction that exposes the append-only write semantics of mobile UFS flash to the OS, cutting write amplification and GC overhead by an order of magnitude on mobile workloads.
+
+---
+
+### Ethane: An Asymmetric File System for Disaggregated Persistent Memory
+
+*Miao Cai 0001, Junru Shen, Baoliu Ye*
+
+**TL;DR** — Proposes a split-path file system design where reads bypass the server entirely and writes use lightweight logging, achieving near-DRAM read latency on disaggregated persistent memory.
+
+---
+
+### StreamCache: Revisiting Page Cache for File Scanning on Fast Storage Devices
+
+*Zhiyue Li, Guangyan Zhang*
+
+**TL;DR** — Demonstrates that the Linux page cache becomes a bottleneck — not a benefit — for sequential scans on NVMe SSDs, and replaces it with a lightweight streaming buffer that halves latency for analytical workloads.
+
+---
+
+### PeRF: Preemption-enabled RDMA Framework
+
+*Sugi Lee, Mingyu Choi, Ikjun Yeom, Younghoon Kim*
+
+**TL;DR** — Adds fine-grained preemption to RDMA by intercepting work-queue operations at the NIC driver level, enabling priority isolation for latency-sensitive RPC traffic sharing a fabric with bulk transfers.
+
+---
+
+### OSMOSIS: Enabling Multi-Tenancy in Datacenter SmartNICs
+
+*Mikhail Khalilov, Marcin Chrapek, Siyuan Shen, Alessandro Vezzu *et al.**
+
+**TL;DR** — Designs an OS-like resource manager for SmartNIC compute and memory that enforces tenant isolation and QoS, showing that shared-SmartNIC deployments are practical without sacrificing performance.
+
+---
+
+### mmTLS: Scaling the Performance of Encrypted Network Traffic Inspection
+
+*Junghan Yoon, Seunghyun Do, Duckwoo Kim, Taejoong Chung *et al.**
+
+**TL;DR** — Splits TLS session state across multiple cores using a novel sharding scheme, removing the per-connection serialization bottleneck in middlebox TLS inspection and achieving near-linear multi-core scaling.
+
+---
+
+### UniMem: Redesigning Disaggregated Memory within A Unified Local-Remote Memory Hierarchy
+
+*Yijie Zhong, Minqiang Zhou, Zhirong Shen, Jiwu Shu*
+
+**TL;DR** — Collapses the local/remote memory distinction into a single unified hierarchy with a new page-placement runtime, achieving transparent memory disaggregation with significantly lower tail latency than prior CXL-based approaches.
+

site/content/cloud-edge/digests/ATC-2025/index.md

@@ -0,0 +1,172 @@
+---
+title: ATC 2025 Digest
+venue: ATC
+year: 2025
+date: '2025-07-09'
+tags:
+- operating-systems
+- cloud
+- storage
+- networking
+paper_count: 13
+draft: false
+---
+
+13 papers selected.
+
+---
+
+### ASTERINAS: A Linux ABI-Compatible, Rust-Based Framekernel OS with a Small and Sound TCB
+
+*Yuke Peng, Hongliang Tian, Junyang Zhang, Ruihan Li *et al.**
+
+**TL;DR** — A production-grade OS kernel written in Rust that exposes a full Linux ABI while confining unsafe code to a small, formally-audited framekernel core.
+
+**Why notable** — ASTERINAS demonstrates that Linux compatibility and memory-safety guarantees are not mutually exclusive — unsafe Rust is isolated to under 5 kloc of framework code, giving systems operators a credible path toward a safer Linux-compatible kernel without sacrificing application portability.
+
+[→ Read paper](https://www.usenix.org/conference/atc25/presentation/peng-yuke)
+
+---
+
+### Rex: Closing the language-verifier gap with safe and usable kernel extensions
+
+*Jinghao Jia, Ruowen Qin, Milo Craun, Egor Lukiyanov *et al.**
+
+**TL;DR** — Rex introduces a new kernel-extension framework that replaces eBPF's in-kernel verifier with a Rust-typed, LLVM-based toolchain to safely express programs that eBPF currently rejects.
+
+**Why notable** — The eBPF verifier's conservatism silently limits what practitioners can implement; Rex shows how a language-level safety guarantee can replace ad-hoc bytecode verification without changing the kernel ABI, opening the door to far richer kernel extensions.
+
+[→ Read paper](https://www.usenix.org/conference/atc25/presentation/jia)
+
+---
+
+### PageFlex: Flexible and Efficient User-space Delegation of Linux Paging Policies with eBPF
+
+*Anil Yelam, Kan Wu, Zhiyuan Guo, Suli Yang *et al.**
+
+**TL;DR** — PageFlex lets applications plug in custom page-replacement and allocation policies via eBPF hooks without modifying the kernel, achieving performance competitive with kernel-native policies.
+
+**Why notable** — Memory management policy has historically been locked inside the kernel; PageFlex's eBPF delegation mechanism gives cloud operators a principled way to tailor paging behavior per workload, directly addressing the one-size-fits-all limitation of the Linux page allocator.
+
+[→ Read paper](https://www.usenix.org/conference/atc25/presentation/yelam)
+
+---
+
+### μEFI: A Microkernel-Style UEFI with Isolation and Transparency
+
+*Le Chen, Yiyang Wu, Jinyu Gu 0001, Yubin Xia *et al.**
+
+**TL;DR** — μEFI restructures UEFI firmware around microkernel principles so that individual UEFI drivers are isolated from each other and from the boot-time trusted computing base.
+
+**Why notable** — Firmware vulnerabilities are notoriously hard to patch and can persist through OS reinstalls; μEFI's approach substantially reduces the blast radius of a compromised UEFI driver while remaining compatible with existing UEFI software, making it directly relevant to secure-boot infrastructure.
+
+[→ Read paper](https://www.usenix.org/conference/atc25/presentation/chen-le)
+
+---
+
+### Z-LFS: A Zoned Namespace-tailored Log-structured File System for Commodity Small-zone ZNS SSDs
+
+*Inhwi Hwang, Sangjin Lee 0003, Sunggon Kim, Hyeonsang Eom *et al.**
+
+**TL;DR** — Z-LFS is an LFS designed around the tight zone-size constraints of commodity ZNS SSDs, using fine-grained segment management and zone-aware garbage collection to avoid the capacity and write-amplification pitfalls of existing approaches.
+
+**Why notable** — ZNS SSDs offer significant cost and endurance advantages but mainstream file systems waste capacity on small-zone devices; Z-LFS shows that rethinking LFS segment layout specifically for small zones yields competitive throughput with substantially lower write amplification.
+
+[→ Read paper](https://www.usenix.org/conference/atc25/presentation/hwang)
+
+---
+
+### Crash Consistency in Block-Level Caching Systems: An Open CAS Case Study
+
+*Shaohua Duan, Youmin Chen*
+
+**TL;DR** — A systematic study of crash-consistency bugs in the widely deployed Open CAS block-layer cache, revealing a class of ordering violations that can silently corrupt data on unexpected power loss.
+
+**Why notable** — Block-level caches are invisible to file systems and often assumed to be transparent, making these bugs particularly insidious; the paper's taxonomy and detection methodology are directly actionable for operators running NVMe caching in production storage stacks.
+
+[→ Read paper](https://www.usenix.org/conference/atc25/presentation/duan-shaohua)
+
+---
+
+### HotRAP: Hot Record Retention and Promotion for LSM-trees with Tiered Storage
+
+*Jiansheng Qiu, Fangzhou Yuan, Mingyu Gao 0001, Huanchen Zhang*
+
+**TL;DR** — HotRAP adds a retention-and-promotion layer to LSM-tree compaction that keeps frequently accessed records in faster storage tiers by tracking access heat across compaction boundaries.
+
+**Why notable** — Tiered storage deployments with LSM engines (RocksDB, LevelDB) routinely see hot data demoted to slow tiers during compaction; HotRAP's lightweight heat tracking improves read latency by up to 5x on skewed workloads without changing the external LSM API.
+
+[→ Read paper](https://www.usenix.org/conference/atc25/presentation/qiu)
+
+---
+
+### TGW: Operating an Efficient and Resilient Cloud Gateway at Scale
+
+*Yifan Yang 0009, Lin He 0004, Jiasheng Zhou, Xiaoyi Shi *et al.**
+
+**TL;DR** — TGW describes the architecture, traffic engineering, and operational lessons of a production cloud gateway handling hundreds of Tbps at a major cloud provider.
+
+**Why notable** — Production-scale gateway papers with real traffic data are rare; TGW's account of how to sustain sub-millisecond failover and linear-scale throughput under adversarial traffic patterns provides a concrete reference design for anyone building or operating large-scale edge infrastructure.
+
+[→ Read paper](https://www.usenix.org/conference/atc25/presentation/yang-yifan)
+
+---
+
+### SwCC: Software-Programmable and Per-Packet Congestion Control in RDMA Engine
+
+*Hongjing Huang, Jie Zhang 0081, Xuzheng Chen, Ziyu Song *et al.**
+
+**TL;DR** — SwCC embeds a programmable per-packet congestion-control engine directly inside an RDMA NIC, allowing operators to deploy and hot-swap CC algorithms without CPU involvement or ASIC redesign.
+
+**Why notable** — RDMA congestion control has historically been frozen in NIC firmware, forcing cluster-wide firmware upgrades to try new algorithms; SwCC's programmable datapath brings the velocity of software-defined networking to the RDMA layer at near-line-rate performance.
+
+[→ Read paper](https://www.usenix.org/conference/atc25/presentation/huang-hongjing)
+
+---
+
+### Opening Up Kernel-Bypass TCP Stacks
+
+*Shinichi Awamoto, Michio Honda*
+
+**TL;DR** — A framework that exposes kernel-bypass TCP (DPDK-based) stacks to unmodified POSIX applications by transparently interposing at the syscall level, without requiring application changes or root privileges.
+
+**Why notable** — Kernel-bypass networking has been limited to purpose-built applications; this work's zero-modification deployment model makes microsecond-latency TCP accessible to the broad ecosystem of existing networked software, which has significant practical implications for latency-sensitive cloud services.
+
+[→ Read paper](https://www.usenix.org/conference/atc25/presentation/awamoto)
+
+---
+
+### Accelerating Nested Virtualization with HyperTurtle
+
+*Ori Ben Zur, Jakob Krebs, Shai Aviram Bergman, Mark Silberstein*
+
+**TL;DR** — HyperTurtle reduces the performance penalty of nested virtualization by selectively forwarding L2 guest hypercalls directly to the L0 hypervisor, bypassing the L1 intermediary for common fast paths.
+
+**Why notable** — Nested virtualization is increasingly important for confidential computing and cloud-in-cloud deployments, but the overhead is often prohibitive; HyperTurtle's selective bypass approach cuts nested VM overhead by up to 60% on I/O-intensive workloads with no guest modifications.
+
+[→ Read paper](https://www.usenix.org/conference/atc25/presentation/zur)
+
+---
+
+### KVCache Cache in the Wild: Characterizing and Optimizing KVCache Cache at a Large Cloud Provider
+
+*Jiahao Wang, Jinbo Han, Xingda Wei, Sijie Shen *et al.**
+
+**TL;DR** — A production measurement study of LLM KV-cache behavior across a large cloud fleet, revealing access patterns and reuse characteristics that inform a redesigned caching policy reducing GPU memory pressure significantly.
+
+**Why notable** — As LLM serving becomes a dominant cloud workload, KV-cache management is a critical bottleneck; this paper provides the first at-scale empirical characterization of KV-cache reuse in a real deployment, and its findings directly shaped policy changes that improved cache hit rates by over 30%.
+
+[→ Read paper](https://www.usenix.org/conference/atc25/presentation/wang-jiahao)
+
+---
+
+### GREYHOUND: Hunting Fail-Slows in Hybrid-Parallel Training at Scale
+
+*Tianyuan Wu, Wei Wang 0030, Yinghao Yu, Siran Yang *et al.**
+
+**TL;DR** — GREYHOUND is a runtime monitoring system that automatically detects and isolates fail-slow stragglers in large-scale hybrid-parallel LLM training jobs before they degrade the entire training run.
+
+**Why notable** — Fail-slow faults are notoriously harder to detect than fail-stop failures and can silently extend training jobs by hours; GREYHOUND's production deployment demonstrates that fine-grained per-layer timing signals can catch slow nodes within seconds, making it a practical reliability tool for anyone running large training clusters.
+
+[→ Read paper](https://www.usenix.org/conference/atc25/presentation/wu-tianyuan)
+

site/content/cloud-edge/digests/ATC-2026/index.md

@@ -0,0 +1,13 @@
+---
+title: ATC 2026 Digest
+venue: ATC
+year: 2026
+date: '2026-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/CCGrid-2024/index.md

@@ -0,0 +1,135 @@
+---
+title: CCGrid 2024 Digest
+venue: CCGrid
+year: 2024
+date: '2024-05-06'
+tags:
+- cloud-computing
+- distributed-systems
+- hpc
+paper_count: 10
+draft: false
+---
+
+10 papers selected.
+
+---
+
+### Fair, Efficient Multi-Resource Scheduling for Stateless Serverless Functions with Anubis
+
+*Amit Samanta 0001, Ryan Stutsman*
+
+**TL;DR** — Anubis introduces a fair, multi-resource scheduler for stateless serverless functions that achieves efficiency without sacrificing isolation between tenants.
+
+**Why notable** — Fairness in serverless resource allocation is an open problem as functions compete for heterogeneous resources (CPU, memory, I/O); Anubis provides a concrete, deployable answer. The work directly addresses a gap in production FaaS platforms where existing schedulers optimize for throughput but ignore per-tenant equity.
+
+[→ Read paper](https://doi.org/10.1109/CCGrid59990.2024.00021)
+
+---
+
+### SLO-Power: SLO and Power-aware Elastic Scaling for Web Services
+
+*Mehmet Savasci, Abel Souza, Li Wu, David Irwin 0001 *et al.**
+
+**TL;DR** — SLO-Power co-optimizes SLO compliance and power consumption during elastic scaling of web services, reducing energy use without violating latency targets.
+
+**Why notable** — Jointly chasing SLOs and power budgets is a critical concern for sustainable cloud operations; this work shows the two objectives can be reconciled in a single scaling controller. The approach is directly applicable to cloud autoscaling stacks where energy cost and QoS guarantees are both first-class concerns.
+
+[→ Read paper](https://doi.org/10.1109/CCGrid59990.2024.00025)
+
+---
+
+### HAPPIES: a History-Aware Efficient Cloud Resource Overcommitment System
+
+*Ziwei Huang 0003, Shibo Tang, Zihao Chang, Lin Tan *et al.**
+
+**TL;DR** — HAPPIES uses historical utilization traces to safely overcommit cloud resources, improving cluster efficiency while bounding the risk of SLO violations.
+
+**Why notable** — Resource overcommitment is a primary lever for improving datacenter utilization, and HAPPIES advances the state of the art by making overcommitment decisions history-aware rather than reactive. Its deployment-oriented design makes it immediately relevant to hyperscale cloud operators seeking higher bin-packing ratios.
+
+[→ Read paper](https://doi.org/10.1109/CCGrid59990.2024.00064)
+
+---
+
+### COTuner: Joint Optimization of Resource Configuration and Software Parameters for Recurring Streaming Jobs on the Cloud
+
+*Hui Dou, Shanshan Zhu, Yuxuan Zhou 0005, Yiwen Zhang 0001 *et al.**
+
+**TL;DR** — COTuner simultaneously tunes cloud resource allocation and application-level software knobs for recurring streaming jobs, reducing cost and latency together.
+
+**Why notable** — Streaming workloads on the cloud are poorly served by tools that tune resources and software parameters in isolation; COTuner's joint search closes this gap. The focus on recurring jobs makes the approach practical, amortizing tuning cost over repeated executions in production pipelines.
+
+[→ Read paper](https://doi.org/10.1109/CCGrid59990.2024.00019)
+
+---
+
+### DeepVM: Integrating Spot and On-Demand VMs for Cost-Efficient Deep Learning Clusters in the Cloud
+
+*Yoochan Kim, Kihyun Kim, Yonghyeon Cho, Jinwoo Kim *et al.**
+
+**TL;DR** — DeepVM dynamically mixes spot and on-demand VM instances to build cost-efficient, fault-tolerant deep learning training clusters in the cloud.
+
+**Why notable** — Training large models on cloud infrastructure is expensive, and spot instance preemptions are a major obstacle to reliability; DeepVM provides a principled integration strategy that achieves both cost savings and resilience. The approach is practically significant given the rapid growth of cloud-hosted AI training workloads.
+
+[→ Read paper](https://doi.org/10.1109/CCGrid59990.2024.00034)
+
+---
+
+### Opportunistic Energy-Aware Scheduling for Container Orchestration Platforms Using Graph Neural Networks
+
+*Philipp Raith, Gourav Rattihalli, Aditya Dhakal, Sai Rahul Chalamalasetti *et al.**
+
+**TL;DR** — A GNN-based scheduler for Kubernetes-style container orchestration platforms exploits opportunistic energy signals to reduce power consumption without degrading application performance.
+
+**Why notable** — Applying graph neural networks to container scheduling captures the complex topology of cluster resources in a way that heuristic schedulers cannot, while the energy-awareness angle addresses the sustainability imperative facing cloud providers. The work bridges recent ML advances with production container orchestration.
+
+[→ Read paper](https://doi.org/10.1109/CCGrid59990.2024.00042)
+
+---
+
+### Jingle: IoT-Informed Autoscaling for Efficient Resource Management in Edge Computing
+
+*Yixuan Wang, Abhishek Chandra, Jon B. Weissman*
+
+**TL;DR** — Jingle leverages real-time IoT device signals to drive predictive autoscaling decisions at the edge, reducing both over-provisioning and latency spikes.
+
+**Why notable** — Edge autoscaling is hampered by the lack of load predictors tuned to IoT event patterns; Jingle fills this gap by treating IoT telemetry as a first-class input to the scaling loop. The result is a tighter edge-cloud integration model with direct relevance to smart-city and industrial IoT deployments.
+
+[→ Read paper](https://doi.org/10.1109/CCGrid59990.2024.00052)
+
+---
+
+### XFBench: A Cross-Cloud Benchmark Suite for Evaluating FaaS Workflow Platforms
+
+*Varad Kulkarni, Nikhil Reddy, Tuhin Khare, Harini Mohan *et al.**
+
+**TL;DR** — XFBench is a portable benchmark suite that evaluates FaaS workflow platforms across multiple cloud providers using representative workload patterns.
+
+**Why notable** — The absence of standardized, cross-cloud benchmarks for serverless workflow platforms hinders fair comparison and informed vendor selection; XFBench addresses this directly with a reusable, community-shareable artifact. It covers diverse workflow shapes and exposes platform-specific performance cliffs that single-provider benchmarks miss.
+
+[→ Read paper](https://doi.org/10.1109/CCGrid59990.2024.00067)
+
+---
+
+### Hades: A Context-Aware Active Storage Framework for Accelerating Large-Scale Data Analysis
+
+*Jaime Cernuda, Luke Logan, Ana Gainaru, Scott Klasky *et al.**
+
+**TL;DR** — Hades pushes data transformations into the storage layer using context-aware active storage, dramatically reducing I/O traffic and accelerating large-scale scientific data analysis.
+
+**Why notable** — As HPC datasets grow to petabyte scale, moving data to compute becomes the dominant bottleneck; Hades revives and modernizes the active-storage model with context awareness to match modern workflow patterns. The work is highly relevant to HPC-cloud convergence efforts where storage and compute are increasingly disaggregated.
+
+[→ Read paper](https://doi.org/10.1109/CCGrid59990.2024.00070)
+
+---
+
+### Workflow Mini-Apps: Portable, Scalable, Tunable & Faithful Representations of Scientific Workflows
+
+*Ozgur O. Kilic, Tianle Wang 0001, Matteo Turilli, Mikhail Titov *et al.**
+
+**TL;DR** — Workflow Mini-Apps are compact, parameterizable proxies that faithfully capture the performance behavior of full scientific workflows, enabling portable scheduling research without the overhead of running complete pipelines.
+
+**Why notable** — Scientific workflow scheduling research is bottlenecked by the cost and complexity of running real applications at scale; mini-apps lower this barrier while preserving the key performance characteristics needed for valid scheduler evaluation. The methodology is immediately reusable by the broader distributed workflow community.
+
+[→ Read paper](https://doi.org/10.1109/CCGrid59990.2024.00059)
+

site/content/cloud-edge/digests/CCGrid-2026/index.md

@@ -0,0 +1,13 @@
+---
+title: CCGrid 2026 Digest
+venue: CCGrid
+year: 2026
+date: '2026-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/EuroSys-2024/index.md

@@ -0,0 +1,116 @@
+---
+title: EuroSys 2024 Digest
+venue: EuroSys
+year: 2024
+date: '2024-01-01'
+tags: []
+paper_count: 13
+draft: false
+---
+
+13 papers selected.
+
+---
+
+### Pronghorn: Effective Checkpoint Orchestration for Serverless Hot-Starts
+
+*Sumer Kohli, Shreyas Kharbanda, Rodrigo Bruno, João Carreira *et al.**
+
+**TL;DR** — Demonstrates how carefully orchestrated checkpointing can eliminate cold-start latency in serverless runtimes, achieving near-instant hot-starts with negligible overhead.
+
+---
+
+### Serialization/Deserialization-free State Transfer in Serverless Workflows
+
+*Fangming Lu, Xingda Wei, Zhuobin Huang, Rong Chen 0001 *et al.**
+
+**TL;DR** — Eliminates the dominant serialization cost in serverless function chaining by enabling direct in-memory state passing, yielding large end-to-end latency reductions.
+
+---
+
+### SplitFT: Fault Tolerance for Disaggregated Datacenters via Remote Memory Logging
+
+*Xuhao Luo, Ramnatthan Alagappan, Aishwarya Ganesan*
+
+**TL;DR** — Proposes a principled fault-tolerance design for disaggregated datacenters that exploits the new memory-compute split to recover from failures with low overhead.
+
+---
+
+### Puddles: Application-Independent Recovery and Location-Independent Data for Persistent Memory
+
+*Suyash Mahar, Mingyao Shen, TJ Smith, Joseph Izraelevitz *et al.**
+
+**TL;DR** — Provides transparent crash consistency and data relocation for persistent memory without requiring application changes, easing adoption of PM-backed storage.
+
+---
+
+### Enoki: High Velocity Linux Kernel Scheduler Development
+
+*Samantha Miller, Anirudh Kumar, Tanay Vakharia, Ang Chen 0001 *et al.**
+
+**TL;DR** — Enables safe, rapid iteration on Linux CPU schedulers by isolating scheduling logic in user space while keeping kernel integration, dramatically lowering the development barrier.
+
+---
+
+### Transparent Multicore Scaling of Single-Threaded Network Functions
+
+*Lei Yan 0003, Yueyang Pan, Diyu Zhou, George Candea *et al.**
+
+**TL;DR** — Automatically parallelizes unmodified single-threaded network functions across cores with correctness guarantees, delivering near-linear throughput scaling without code changes.
+
+---
+
+### Hoda: a High-performance Open vSwitch Dataplane with Multiple Specialized Data Paths
+
+*Heng Pan, Peng He 0003, Zhenyu Li 0001, Pan Zhang *et al.**
+
+**TL;DR** — Redesigns the Open vSwitch dataplane with multiple specialized fast paths, achieving significant throughput improvements for cloud virtual networking.
+
+---
+
+### SmartNIC Security Isolation in the Cloud with S-NIC
+
+*Yang Zhou 0008, Mark Wilkening, James Mickens, Minlan Yu*
+
+**TL;DR** — Introduces hardware-enforced security isolation for SmartNIC offload tasks in multi-tenant clouds, preventing cross-tenant attacks without sacrificing offload performance.
+
+---
+
+### Finding Correctness Bugs in eBPF Verifier with Structured and Sanitized Program
+
+*Hao Sun 0021, Yiru Xu, Jianzhong Liu, Yuheng Shen *et al.**
+
+**TL;DR** — Systematically uncovers verifier logic bugs that can silently allow unsafe eBPF programs to execute in the kernel, with a structured fuzzing approach validated on the Linux eBPF verifier.
+
+---
+
+### CSAL: the Next-Gen Local Disks for the Cloud
+
+*Yanbo Zhou, Erci Xu, Li Zhang, Kapil Karkra *et al.**
+
+**TL;DR** — Describes a production cloud local-disk system that replaces raw NVMe with a software-defined layer to deliver better performance, reliability, and operational flexibility at hyperscale.
+
+---
+
+### Volley: Accelerating Write-Read Orders in Disaggregated Storage
+
+*Shaoxun Zeng, Xiaojian Liao, Hao Guo, Youyou Lu*
+
+**TL;DR** — Addresses write-read ordering hazards in disaggregated storage by pipelining acknowledgements with read-side tracking, substantially reducing tail latency without weakening durability.
+
+---
+
+### Erlang: Application-Aware Autoscaling for Cloud Microservices
+
+*Vighnesh Sachidananda, Anirudh Sivaraman*
+
+**TL;DR** — Leverages application-level call-graph semantics to make autoscaling decisions that are both faster and more accurate than black-box reactive policies, cutting SLO violations in microservice deployments.
+
+---
+
+### Automatic Root Cause Analysis via Large Language Models for Cloud Incidents
+
+*Yinfang Chen, Huaibing Xie, Minghua Ma, Yu Kang 0006 *et al.**
+
+**TL;DR** — Demonstrates an LLM-driven pipeline for automated cloud-incident root cause analysis deployed at Microsoft Azure, showing strong recall and significant reduction in on-call engineer effort.
+

site/content/cloud-edge/digests/EuroSys-2025/index.md

@@ -0,0 +1,178 @@
+---
+title: EuroSys 2025 Digest
+venue: EuroSys
+year: 2025
+date: '2025-03-30'
+tags:
+- operating-systems
+- distributed-systems
+- cloud
+- storage
+- memory
+- networking
+- llm-systems
+- security
+- hardware-software-co-design
+- serverless
+paper_count: 13
+draft: false
+---
+
+13 papers selected.
+
+---
+
+### Empowering WebAssembly with Thin Kernel Interfaces
+
+*Arjun Ramesh, Tianshu Huang, Ben L. Titzer, Anthony Rowe 0001*
+
+**TL;DR** — A new OS interface design exposes thin, capability-based kernel primitives directly to WebAssembly modules, eliminating the POSIX translation layer.
+
+**Why notable** — WebAssembly is increasingly used beyond the browser as a portable, sandboxed compute substrate; this work shows that rethinking the system interface from scratch yields significantly lower overhead and better safety properties than layering Wasm on top of POSIX.
+
+[→ Read paper](https://doi.org/10.1145/3689031.3717470)
+
+---
+
+### Revealing the Unstable Foundations of eBPF-Based Kernel Extensions
+
+*Shawn Wanxiang Zhong, Jing Liu 0074, Andrea C. Arpaci-Dusseau, Remzi H. Arpaci-Dusseau*
+
+**TL;DR** — A systematic study exposes how eBPF programs silently break across kernel versions due to undocumented and unstable kernel data structure dependencies.
+
+**Why notable** — From the Arpaci-Dusseau group, this paper delivers surprising and practically consequential findings: a large fraction of real-world eBPF programs are fragile across kernel versions, undermining the widely held assumption that eBPF is a safe and stable extension mechanism.
+
+[→ Read paper](https://doi.org/10.1145/3689031.3717497)
+
+---
+
+### Pegasus: Transparent and Unified Kernel-Bypass Networking for Fast Local and Remote Communication
+
+*Dinglan Peng, Congyu Liu, Tapti Palit, Anjo Vahldiek-Oberwagner *et al.**
+
+**TL;DR** — Pegasus provides a single kernel-bypass networking stack that transparently accelerates both intra-host (IPC) and inter-host communication without application changes.
+
+**Why notable** — Unifying local and remote fast paths is a long-standing challenge; Pegasus demonstrates that the same RDMA-style techniques can be applied to loopback traffic, yielding substantial latency reductions for microservice workloads with no API changes.
+
+[→ Read paper](https://doi.org/10.1145/3689031.3696083)
+
+---
+
+### Daredevil: Rescue Your Flash Storage from Inflexible Kernel Storage Stack
+
+*Junzhe Li, Ran Shu 0001, Jiayi Lin 0007, Qingyu Zhang 0005 *et al.**
+
+**TL;DR** — Daredevil bypasses the rigid Linux block layer to allow flash storage devices to express fine-grained I/O semantics directly to applications.
+
+**Why notable** — The Linux storage stack was designed for spinning disks and consistently imposes unnecessary overhead on modern NVMe SSDs; Daredevil demonstrates that rethinking the kernel/device interface boundary unlocks significant throughput and latency gains that the existing stack structurally prevents.
+
+[→ Read paper](https://doi.org/10.1145/3689031.3717482)
+
+---
+
+### Towards Efficient Flash Caches with Emerging NVMe Flexible Data Placement SSDs
+
+*Michael Allison, Arun George, Javier González 0006, Dan Helmick *et al.**
+
+**TL;DR** — This paper shows how NVMe Flexible Data Placement (FDP) SSDs can be exploited by flash cache software to dramatically reduce write amplification and improve device lifetime.
+
+**Why notable** — FDP is a newly standardized NVMe feature; this is one of the first systems papers to demonstrate end-to-end integration with a production-grade flash caching stack, revealing concrete performance and endurance benefits that motivate wider adoption.
+
+[→ Read paper](https://doi.org/10.1145/3689031.3696091)
+
+---
+
+### Chrono: Meticulous Hotness Measurement and Flexible Page Migration for Memory Tiering
+
+*Zhenlin Qi, Shengan Zheng, Ying Huang, Yifeng Hui *et al.**
+
+**TL;DR** — Chrono introduces fine-grained, low-overhead hotness tracking and a flexible page migration policy that adapts to workload dynamics for tiered memory systems.
+
+**Why notable** — As CXL-based memory tiering becomes a reality in data centers, accurate hotness estimation is critical; Chrono's approach substantially outperforms existing kernel mechanisms and sets a new baseline for OS-level tiered memory management.
+
+[→ Read paper](https://doi.org/10.1145/3689031.3717462)
+
+---
+
+### Adios to Busy-Waiting for Microsecond-scale Memory Disaggregation
+
+*Wonsup Yoon, Jisu Ok, Sue Moon, Youngjin Kwon*
+
+**TL;DR** — This work eliminates CPU-wasting busy-waiting in disaggregated memory systems by designing interrupt-driven mechanisms that still meet microsecond latency targets.
+
+**Why notable** — Busy-waiting is the conventional wisdom for achieving low latency in disaggregated memory, yet it burns entire CPU cores; this paper challenges that assumption and shows interrupt-based designs can match latency while freeing substantial compute, which matters greatly at scale.
+
+[→ Read paper](https://doi.org/10.1145/3689031.3717475)
+
+---
+
+### Collaborative Text Editing with Eg-walker: Better, Faster, Smaller
+
+*Joseph Gentle, Martin Kleppmann*
+
+**TL;DR** — Eg-walker is a new CRDT algorithm for collaborative text editing that is simultaneously faster, more memory-efficient, and produces smaller operation logs than prior state-of-the-art CRDTs.
+
+**Why notable** — Collaborative editing CRDTs have been considered a mature area, making it surprising that Eg-walker achieves order-of-magnitude improvements across all key metrics; the result, from Martin Kleppmann, will likely become the new reference design for replicated text data structures.
+
+[→ Read paper](https://doi.org/10.1145/3689031.3696076)
+
+---
+
+### Ladon: High-Performance Multi-BFT Consensus via Dynamic Global Ordering
+
+*Hanzheng Lyu, Shaokang Xie, Jianyu Niu, Chen Feng 0001 *et al.**
+
+**TL;DR** — Ladon achieves high throughput in Byzantine fault-tolerant consensus by running multiple BFT instances in parallel and dynamically merging their outputs into a consistent global order.
+
+**Why notable** — Byzantine consensus is notoriously throughput-limited; Ladon's multi-instance approach with a novel global ordering layer demonstrates near-linear throughput scaling with the number of consensus instances, a significant advance for permissioned blockchain and critical-infrastructure scenarios.
+
+[→ Read paper](https://doi.org/10.1145/3689031.3696102)
+
+---
+
+### HybridFlow: A Flexible and Efficient RLHF Framework
+
+*Guangming Sheng, Chi Zhang 0022, Zilingfeng Ye, Xibin Wu *et al.**
+
+**TL;DR** — HybridFlow introduces a hybrid dataflow model for RLHF training that co-schedules the actor, critic, and reward models to maximize GPU utilization across heterogeneous cluster configurations.
+
+**Why notable** — RLHF has become central to LLM alignment yet existing frameworks map poorly to its multi-model, tightly coupled training loop; HybridFlow's design substantially improves end-to-end training throughput and provides a principled abstraction for future alignment training research.
+
+[→ Read paper](https://doi.org/10.1145/3689031.3696075)
+
+---
+
+### CacheBlend: Fast Large Language Model Serving for RAG with Cached Knowledge Fusion
+
+*Jiayi Yao, Hanchen Li, Yuhan Liu 0004, Siddhant Ray *et al.**
+
+**TL;DR** — CacheBlend reuses KV caches from multiple pre-computed document chunks and fuses them selectively at inference time, avoiding the quadratic cost of full re-encoding for retrieval-augmented generation.
+
+**Why notable** — RAG is a dominant LLM deployment pattern, but cache reuse across dynamically assembled contexts is unsolved; CacheBlend's selective fusion strategy delivers large time-to-first-token reductions with negligible quality degradation, directly improving the economics of production LLM serving.
+
+[→ Read paper](https://doi.org/10.1145/3689031.3696098)
+
+---
+
+### AlloyStack: A Library Operating System for Serverless Workflow Applications
+
+*Jianing You, Kang Chen, Laiping Zhao, Yiming Li *et al.**
+
+**TL;DR** — AlloyStack is a library OS tailored for serverless workflows that collapses function boundaries within a workflow into a single address space to eliminate inter-function communication overhead.
+
+**Why notable** — Serverless workflows suffer from high invocation and communication latency because each function is an isolated container; AlloyStack's library OS approach is a principled architectural answer that shows substantial end-to-end latency and cost improvements for real workflow benchmarks.
+
+[→ Read paper](https://doi.org/10.1145/3689031.3717490)
+
+---
+
+### CRAVE: Analyzing Cross-Resource Interaction to Improve Energy Efficiency in Systems-on-Chip
+
+*Dipayan Mukherjee, Sam Hachem, Jeremy Bao, Curtis Madsen *et al.**
+
+**TL;DR** — CRAVE models the cross-resource interference between CPU, GPU, and memory subsystems on SoCs to guide software-level energy optimization decisions.
+
+**Why notable** — Energy efficiency is increasingly a first-class constraint in both mobile and data center SoCs, yet interactions between on-chip resources are poorly understood at the software level; CRAVE's analysis framework reveals counter-intuitive interference patterns and enables measurable energy savings without hardware changes.
+
+[→ Read paper](https://doi.org/10.1145/3689031.3717498)
+

site/content/cloud-edge/digests/EuroSys-2027/index.md

@@ -0,0 +1,13 @@
+---
+title: EuroSys 2027 Digest
+venue: EuroSys
+year: 2027
+date: '2027-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/FGCS-2024/index.md

@@ -0,0 +1,132 @@
+---
+title: FGCS 2024 Digest
+venue: FGCS
+year: 2024
+date: '2024-01-01'
+tags: []
+paper_count: 12
+draft: false
+---
+
+12 papers selected.
+
+---
+
+### Quantum-centric supercomputing for materials science: A perspective on challenges and future directions
+
+*Yuri Alexeev, Maximilian Amsler, Marco Antonio Barroca, Sanzio Bassini *et al.**
+
+**TL;DR** — A comprehensive roadmap from IBM, national labs, and universities identifying key algorithmic, software, and hardware challenges for using quantum processors alongside classical HPC to advance materials science simulations.
+
+**Why notable** — Essential reading for any researcher planning quantum-classical hybrid workflows, covering the full stack from error mitigation to application mapping at scale.
+
+---
+
+### Integrating quantum computing resources into scientific HPC ecosystems
+
+*Thomas L. Beck, Alessandro Baroni 0003, Ryan S. Bennink, Gilles Buchs *et al.**
+
+**TL;DR** — Describes the architecture and middleware decisions made at Oak Ridge National Laboratory to expose quantum devices as first-class resources within an existing HPC facility.
+
+**Why notable** — One of the first concrete descriptions of a production-scale quantum-HPC integration, providing a template other facilities can follow.
+
+---
+
+### Lotaru: Locally predicting workflow task runtimes for resource management on heterogeneous infrastructures
+
+*Jonathan Bader, Fabian Lehmann, Lauritz Thamsen, Ulf Leser *et al.**
+
+**TL;DR** — Lotaru learns lightweight per-workflow runtime prediction models locally on each node using micro-benchmarks, eliminating the need for a centralized profiling service on heterogeneous clusters.
+
+**Why notable** — Addresses a core bottleneck in scientific workflow scheduling with a practical, evaluated approach that works without historical traces.
+
+---
+
+### The globus compute dataset: An open function-as-a-service dataset from the edge to the cloud
+
+*André Bauer 0001, Haochen Pan, Ryan Chard, Yadu N. Babuji *et al.**
+
+**TL;DR** — Releases a large real-world dataset of function invocations across edge, campus, and cloud resources collected from the Globus Compute FaaS platform, along with workload analysis.
+
+**Why notable** — Provides the community with a rare, richly annotated dataset for benchmarking distributed FaaS schedulers and studying edge-to-cloud task patterns at scale.
+
+---
+
+### A survey on checkpointing strategies: Should we always checkpoint à la Young/Daly?
+
+*Leonardo Bautista-Gomez, Anne Benoit, Sheng Di, Thomas Hérault *et al.**
+
+**TL;DR** — Surveys decades of checkpointing research and rigorously examines when the classic Young/Daly formula is optimal versus when multi-level, coordinated, or application-aware strategies outperform it.
+
+**Why notable** — A definitive reference for HPC fault tolerance that unifies scattered results and provides clear guidance on choosing a checkpointing strategy for modern exascale workloads.
+
+---
+
+### Scalable I/O aggregation for asynchronous multi-level checkpointing
+
+*Mikaila J. Gossman, Bogdan Nicolae, Jon C. Calhoun*
+
+**TL;DR** — Proposes an aggregation layer that pipelines writes across multiple memory and storage tiers asynchronously, reducing checkpoint overhead for large-scale MPI applications.
+
+**Why notable** — Delivers measurable improvements in checkpoint throughput on realistic HPC applications, directly addressing the I/O bottleneck at exascale.
+
+---
+
+### StructMesh: A storage framework for serverless computing continuum
+
+*Diana Carrizales-Espinoza, Dante D. Sánchez-Gallegos, José Luis González Compeán, Jesús Carretero 0001*
+
+**TL;DR** — Introduces a hierarchical storage abstraction that unifies data management across edge, fog, and cloud tiers for serverless workflows, supporting structured data access patterns.
+
+**Why notable** — Offers a practical, evaluated solution to the data management gap in cloud-edge serverless architectures, relevant to scientific and industrial workflow deployment.
+
+---
+
+### Paving the way to hybrid quantum-classical scientific workflows
+
+*Sandeep Suresh Cranganore, Vincenzo De Maio, Ivona Brandic, Ewa Deelman*
+
+**TL;DR** — Defines a taxonomy and reference architecture for hybrid quantum-classical workflows, mapping quantum circuit execution onto existing scientific workflow management system abstractions.
+
+**Why notable** — Provides the conceptual foundations needed to extend tools like Pegasus or Swift to orchestrate quantum subroutines within larger scientific pipelines.
+
+---
+
+### Online learning and continuous model upgrading with data streams through the Kafka-ML framework
+
+*Alejandro Carnero, Cristian Martín 0002, Gwanggil Jeon, Manuel Díaz*
+
+**TL;DR** — Extends Kafka-ML to support incremental online learning directly from streaming data topics, enabling continuous model updates without retraining from scratch in edge-cloud deployments.
+
+**Why notable** — Demonstrates a full open-source framework that bridges stream processing and ML model lifecycle management, with relevance to IoT and real-time analytics pipelines.
+
+---
+
+### GRAAFE: GRaph Anomaly Anticipation Framework for Exascale HPC systems
+
+*Martin Molan, Mohsen Seyedkazemi Ardebili, Junaid Ahmed Khan, Francesco Beneventi *et al.**
+
+**TL;DR** — Uses graph neural networks trained on node telemetry to predict imminent failures in exascale HPC clusters before they occur, enabling proactive maintenance and job migration.
+
+**Why notable** — Shows that temporal graph models over system topology substantially outperform per-node anomaly detection, with validation on a real pre-exascale machine.
+
+---
+
+### QFaaS: A Serverless Function-as-a-Service framework for Quantum computing
+
+*Hoa T. Nguyen, Muhammad Usman 0009, Rajkumar Buyya*
+
+**TL;DR** — Proposes QFaaS, a broker-based FaaS platform that abstracts heterogeneous quantum hardware providers behind a unified serverless interface with automatic circuit compilation and resource selection.
+
+**Why notable** — Addresses the pressing need for a cloud-agnostic quantum execution layer, laying groundwork for portable quantum applications across IBM, IonQ, and similar backends.
+
+---
+
+### Enabling federated learning across the computing continuum: Systems, challenges and future directions
+
+*Cèdric Prigent, Alexandru Costan, Gabriel Antoniu, Loïc Cudennec*
+
+**TL;DR** — Systematically surveys the technical barriers to training federated learning models that span IoT devices, edge servers, and cloud data centers, and proposes a reference architecture addressing heterogeneity and mobility.
+
+**Why notable** — A timely synthesis that clarifies open problems at the intersection of federated learning and the compute continuum, useful as a roadmap for system builders.
+

site/content/cloud-edge/digests/FGCS-2025/index.md

@@ -0,0 +1,132 @@
+---
+title: FGCS 2025 Digest
+venue: FGCS
+year: 2025
+date: '2025-01-01'
+tags: []
+paper_count: 12
+draft: false
+---
+
+12 papers selected.
+
+---
+
+### Multifacets of lossy compression for scientific data in the Joint-Laboratory of Extreme Scale Computing
+
+*Franck Cappello, Mario C. Acosta, Emmanuel Agullo, Hartwig Anzt *et al.**
+
+**TL;DR** — A joint JLESC survey covering error-bounded lossy compressors (SZ, ZFP, MGARD) across simulation, AI, and in-situ analytics use cases, with benchmarks on real scientific datasets at extreme scale.
+
+**Why notable** — The most comprehensive cross-site evaluation of scientific data compression to date, providing actionable guidance on compressor selection for different numerical kernels and accuracy requirements.
+
+---
+
+### Efficient distributed continual learning for steering experiments in real-time
+
+*Thomas Bouvier, Bogdan Nicolae, Alexandru Costan, Tekin Bicer *et al.**
+
+**TL;DR** — Proposes a distributed continual learning architecture that keeps deep learning models synchronized with a running scientific experiment by streaming lightweight updates across edge detectors and HPC backends.
+
+**Why notable** — One of the first systems to close the loop between experimental data streams and model adaptation in real-time without full retraining, validated on synchrotron detector workloads.
+
+---
+
+### SmartKV: A cost-effective and low-latency geo-distributed key-value store for the computing continuum
+
+*Juan Aznar-Poveda, Maximilian Franz Ebner, Thomas Fahringer, Zahra Najafabadi Samani *et al.**
+
+**TL;DR** — Introduces SmartKV, a geo-distributed key-value store that uses latency-aware replication policies to deliver consistent low-latency reads across edge, fog, and cloud tiers of the computing continuum.
+
+**Why notable** — Provides a concrete, benchmarked storage primitive for the computing continuum that fills the gap between single-datacenter stores and high-latency cloud object storage.
+
+---
+
+### Scalable compute continuum
+
+*Valeria Cardellini, Patrizio Dazzi, Gabriele Mencagli, Matteo Nardelli 0001 *et al.**
+
+**TL;DR** — Defines a programming and deployment model for the compute continuum that abstracts resource heterogeneity from edge to cloud, enabling applications to scale dynamically across tiers.
+
+**Why notable** — Provides a principled architectural reference for the continuum that can guide system designers building next-generation distributed runtime environments.
+
+---
+
+### A comparative study of ad-hoc file systems for extreme scale computing
+
+*Njoud O. Almaaitah, Francisco Javier García Blas, Genaro Sanchez-Gallegos, Jesús Carretero 0001 *et al.**
+
+**TL;DR** — Benchmarks GekkoFS, BeeGFS, and similar ad-hoc file systems under diverse HPC I/O patterns, characterizing their throughput, metadata performance, and suitability for burst-buffer scenarios.
+
+**Why notable** — The most systematic evaluation of ad-hoc parallel file systems available, giving HPC centers clear data to choose or configure temporary storage for large scientific workflows.
+
+---
+
+### Advancing anomaly detection in computational workflows with active learning
+
+*Krishnan Raghavan, George Papadimitriou 0002, Hongwei Jin, Anirban Mandal *et al.**
+
+**TL;DR** — Applies active learning to reduce the labeling burden for workflow anomaly detection, selectively querying an oracle for the most informative execution traces within a Pegasus workflow framework.
+
+**Why notable** — Demonstrates that active learning can make anomaly detection practical in real scientific workflows where labeled failure data is scarce, with experiments on production workloads.
+
+---
+
+### MITgcm-AD v2: Open source tangent linear and adjoint modeling framework for the oceans and atmosphere enabled by the Automatic Differentiation tool Tapenade
+
+*Shreyas Sunil Gaikwad, Sri Hari Krishna Narayanan, Laurent Hascoët, Jean-Michel Campin *et al.**
+
+**TL;DR** — Describes MITgcm-AD v2, a production-quality adjoint of the MITgcm ocean-atmosphere model generated with Tapenade, enabling global sensitivity analyses and data assimilation at scale.
+
+**Why notable** — A landmark in scientific computing software sustainability: a fully open, differentiable climate model that enables gradient-based inversion for ocean state estimation.
+
+---
+
+### zCeph: Design and implementation of a ZNS-friendly distributed file system
+
+*Jinyong Ha 0001, Yongseok Son*
+
+**TL;DR** — Redesigns the Ceph distributed file system to exploit Zoned Namespace SSDs natively, eliminating write amplification and improving throughput by aligning file system semantics with ZNS zone constraints.
+
+**Why notable** — Demonstrates how next-generation storage hardware (ZNS SSDs) demands rethinking distributed storage stack designs, with significant performance gains on real hardware.
+
+---
+
+### RADiCe: A Risk Analysis Framework for Data Centers
+
+*Fabian Mastenbroek, Tiziano De Matteis, Vincent van Beek, Alexandru Iosup*
+
+**TL;DR** — Provides a quantitative risk analysis framework for data centers that models cascading failures across power, cooling, and compute subsystems using simulation to estimate availability and cost trade-offs.
+
+**Why notable** — Fills a practical gap for data center operators who need principled tools to evaluate infrastructure resilience beyond simple redundancy rules.
+
+---
+
+### Deadline-constrained security-aware workflow scheduling in hybrid cloud architecture
+
+*Somayeh Abdi, Mohammad Ashjaei, Saad Mubeen*
+
+**TL;DR** — Formulates workflow scheduling in hybrid clouds as a multi-objective problem that jointly minimizes cost and execution time while meeting both deadline and data-security placement constraints.
+
+**Why notable** — One of the few scheduling works that treats security classification of tasks as a first-class constraint alongside performance, with practical validation on scientific workflow benchmarks.
+
+---
+
+### Regen: An object layout regenerator on large-scale production HPC systems
+
+*Dong Kyu Sung, Sunggon Kim, Sangjin Lee 0003, Houjun Tang *et al.**
+
+**TL;DR** — Regen transparently reorganizes the on-disk layout of HDF5 and NetCDF objects in parallel file systems to match actual access patterns, improving I/O performance without application changes.
+
+**Why notable** — Deployed and validated on a production HPC system, showing significant I/O speedups for real scientific datasets, making it immediately relevant to storage administrators.
+
+---
+
+### Formal definition and implementation of reproducibility tenets for computational workflows
+
+*Nicholas J. Pritchard, Andreas Wicenec*
+
+**TL;DR** — Formalizes a set of reproducibility requirements for scientific workflows and implements a verification layer within the DALIUGE workflow engine that checks compliance at design and execution time.
+
+**Why notable** — Provides the community with a concrete, tool-supported definition of workflow reproducibility, moving beyond aspirational guidelines to enforceable runtime checks.
+

site/content/cloud-edge/digests/FGCS-2026/index.md

@@ -0,0 +1,13 @@
+---
+title: FGCS 2026 Digest
+venue: FGCS
+year: 2026
+date: '2026-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/HPDC-2024/index.md

@@ -0,0 +1,108 @@
+---
+title: HPDC 2024 Digest
+venue: HPDC
+year: 2024
+date: '2024-01-01'
+tags: []
+paper_count: 12
+draft: false
+---
+
+12 papers selected.
+
+---
+
+### Efficient all-to-all Collective Communication Schedules for Direct-connect Topologies
+
+*Prithwish Basu, Liangyu Zhao, Jason Fantl, Siddharth Pal *et al.**
+
+**TL;DR** — Derives near-optimal all-to-all collective communication schedules for direct-connect HPC topologies, directly improving bandwidth utilization in large-scale distributed systems.
+
+---
+
+### Reinforcement Learning-based Adaptive Mitigation of Uncorrected DRAM Errors in the Field
+
+*Isaac Boixaderas, Sergi Moré, Javier Bartolome, David Vicente *et al.**
+
+**TL;DR** — Applies reinforcement learning to dynamically mitigate uncorrected DRAM errors at production HPC scale, improving system reliability without sacrificing performance.
+
+---
+
+### IDT: Intelligent Data Placement for Multi-tiered Main Memory with Reinforcement Learning
+
+*Juneseo Chang, Wanju Doh, Yaebin Moon, Eojin Lee *et al.**
+
+**TL;DR** — Presents a reinforcement learning-driven runtime that automatically places data across heterogeneous memory tiers, reducing access latency in HPC nodes with complex memory hierarchies.
+
+---
+
+### FaaSKeeper: Learning from Building Serverless Services with ZooKeeper as an Example
+
+*Marcin Copik, Alexandru Calotoiu, Pengyu Zhou, Konstantin Taranov *et al.**
+
+**TL;DR** — Reconstructs ZooKeeper as a fully serverless service and distills concrete design lessons for building stateful distributed coordination primitives on FaaS platforms.
+
+---
+
+### ESG: Pipeline-Conscious Efficient Scheduling of DNN Workflows on Serverless Platforms with Shareable GPUs
+
+*Xinning Hui, Yuanchao Xu 0001, Zhishan Guo, Xipeng Shen*
+
+**TL;DR** — Introduces a pipeline-aware scheduler that shares GPUs across serverless DNN workflow stages, substantially cutting end-to-end latency and GPU idle time.
+
+---
+
+### FASOP: Fast yet Accurate Automated Search for Optimal Parallelization of Transformers on Heterogeneous GPU Clusters
+
+*Sunyeol Hwang, Eungyeong Lee, Hongseok Oh 0003, Youngmin Yi*
+
+**TL;DR** — Provides a fast, model-driven search strategy that finds optimal tensor/pipeline/data parallelism configurations for transformer training on heterogeneous GPU clusters.
+
+---
+
+### Near-Optimal Wafer-Scale Reduce
+
+*Piotr Luczynski, Lukas Gianinazzi, Patrick Iff, Leighton Wilson *et al.**
+
+**TL;DR** — Designs and analyzes near-optimal Reduce collective algorithms tailored to wafer-scale interconnect topology, setting new performance bounds for next-generation HPC hardware.
+
+---
+
+### DataStates-LLM: Lazy Asynchronous Checkpointing for Large Language Models
+
+*Avinash Maurya, Robert Underwood, M. Mustafa Rafique, Franck Cappello *et al.**
+
+**TL;DR** — Introduces lazy asynchronous checkpointing that overlaps LLM training with I/O, dramatically reducing checkpoint overhead on large-scale HPC storage systems.
+
+---
+
+### ADTopk: All-Dimension Top-k Compression for High-Performance Data-Parallel DNN Training
+
+*Zhangqiang Ming, Yuchong Hu, Wenxiang Zhou, Xinjue Zheng *et al.**
+
+**TL;DR** — Proposes an all-dimension top-k gradient sparsification scheme that reduces communication volume in data-parallel distributed training while preserving convergence quality.
+
+---
+
+### Accelerating Function-Centric Applications by Discovering, Distributing, and Retaining Reusable Context in Workflow Systems
+
+*Thanh Son Phung, Colin Thomas, Logan T. Ward, Kyle Chard *et al.**
+
+**TL;DR** — Introduces context reuse across scientific workflow tasks, allowing distributed workflow systems to cache and share intermediate computation artifacts and significantly reduce redundant work.
+
+---
+
+### CereSZ: Enabling and Scaling Error-bounded Lossy Compression on Cerebras CS-2
+
+*Shihui Song, Yafan Huang, Peng Jiang 0004, Xiaodong Yu 0001 *et al.**
+
+**TL;DR** — Ports and scales error-bounded lossy compression to the Cerebras CS-2 wafer-scale engine, enabling significant data reduction for HPC scientific workloads on novel accelerator hardware.
+
+---
+
+### EvoStore: Towards Scalable Storage of Evolving Learning Models
+
+*Robert Underwood, Meghana Madhyastha, Randal C. Burns, Bogdan Nicolae*
+
+**TL;DR** — Designs a storage system that efficiently manages the versioned, incrementally evolving checkpoints produced during large-scale distributed model training, reducing storage overhead and retrieval time.
+

site/content/cloud-edge/digests/HPDC-2025/index.md

@@ -0,0 +1,139 @@
+---
+title: HPDC 2025 Digest
+venue: HPDC
+year: 2025
+date: '2025-07-20'
+tags:
+- hpc
+- distributed-systems
+- networking
+- storage
+- scheduling
+- cloud-hpc
+- performance
+paper_count: 10
+draft: false
+---
+
+10 papers selected.
+
+---
+
+### Parameterized Algorithms for Non-uniform All-to-all
+
+*Ke Fan, Jens Domke, Seydou Ba, Sidharth Kumar*
+
+**TL;DR** — Introduces parameterized algorithms that adapt non-uniform all-to-all collective communication to heterogeneous network topologies, reducing message contention and improving throughput.
+
+**Why notable** — Non-uniform all-to-all is a performance bottleneck in many HPC applications; topology-aware parameterization directly benefits MPI implementations on dragonfly and fat-tree networks at scale.
+
+[→ Read paper](https://doi.org/10.1145/3731545.3731590)
+
+---
+
+### DPU-KV: On the Benefits of DPU Offloading for In-Memory Key-Value Stores at the Edge
+
+*Arjun Kashyap, Yuke Li 0003, Xiaoyi Lu 0001*
+
+**TL;DR** — Offloads key-value store operations to Data Processing Units (DPUs) over RDMA to reduce CPU overhead and tail latency in edge deployments.
+
+**Why notable** — DPU offloading is an emerging paradigm for network-attached smart NICs in HPC clusters; this work provides concrete performance analysis showing when and how much offloading helps, informing future RDMA-based storage designs.
+
+[→ Read paper](https://doi.org/10.1145/3731545.3731571)
+
+---
+
+### TSUE: A Two-Stage Data Update Method for an Erasure Coded Cluster File System
+
+*Zheng Wei, Jing Xing, Yida Gu, Wenjing Huang 0002 *et al.**
+
+**TL;DR** — Proposes a two-stage update scheme for erasure-coded parallel file systems that decouples the logging and parity-update phases to cut write amplification and I/O latency.
+
+**Why notable** — Erasure coding is increasingly used in large-scale HPC storage to replace replication, but update overhead remains a bottleneck; TSUE addresses a core pain point for Lustre- and GPFS-class parallel file systems.
+
+[→ Read paper](https://doi.org/10.1145/3731545.3731577)
+
+---
+
+### LegoIndex: A Scalable and Modular Indexing Framework for Efficient Analysis of Extreme-Scale Particle Data
+
+*Chang Guo, Ning Yan 0002, Lipeng Wan 0001, Zhichao Cao 0002*
+
+**TL;DR** — Presents a composable, multi-level indexing framework for particle simulation datasets that enables efficient query processing at extreme scale without requiring full dataset scans.
+
+**Why notable** — Scientific particle simulations at exascale generate data volumes that overwhelm traditional post-processing pipelines; LegoIndex's modular design allows it to be adapted across different storage backends and query patterns commonly seen in DOE workloads.
+
+[→ Read paper](https://doi.org/10.1145/3731545.3731591)
+
+---
+
+### IPComp: Interpolation Based Progressive Lossy Compression for Scientific Applications
+
+*Zhuoxun Yang, Sheng Di, Longtao Zhang, Ruoyu Li *et al.**
+
+**TL;DR** — Introduces interpolation-driven progressive lossy compression that lets users trade accuracy for compression ratio at query time rather than at write time, without re-compressing stored data.
+
+**Why notable** — Progressive reconstruction is a long-sought capability for HPC I/O; IPComp achieves it with competitive compression ratios and builds on the widely used SZ/ZFP lineage, making adoption in existing scientific workflows straightforward.
+
+[→ Read paper](https://doi.org/10.1145/3731545.3731578)
+
+---
+
+### Advancing Scientific Data Compression via Cross-Field Prediction
+
+*Youyuan Liu, Wenqi Jia 0003, Taolue Yang, Bo Jiang *et al.**
+
+**TL;DR** — Exploits correlations between different physical fields in multi-field scientific datasets to improve lossy compression ratios beyond what single-field methods can achieve.
+
+**Why notable** — Multi-field simulations (climate, combustion, fusion) dominate HPC storage consumption; cross-field prediction represents a principled, generally applicable step change in compression efficiency for these workloads.
+
+[→ Read paper](https://doi.org/10.1145/3731545.3731592)
+
+---
+
+### Flux Emulator: First Insights into Optimizing Scheduling for Exascale HPC
+
+*W. Jay Ashworth, Ian Lumsden, Jim Garlick, Mark Grondona *et al.**
+
+**TL;DR** — Presents an emulation infrastructure for the Flux workload manager that enables scheduling algorithm evaluation at exascale node counts without requiring access to a full exascale machine.
+
+**Why notable** — Validating schedulers at exascale is otherwise infeasible before systems exist; Flux Emulator directly supports the scheduling research needed to maximize utilization of Frontier- and Aurora-class systems.
+
+[→ Read paper](https://doi.org/10.1145/3731545.3735121)
+
+---
+
+### HYPERF: End-to-End Autotuning Framework for High-Performance Computing
+
+*Juseong Park, Yongwon Shin, Junghyun Lee, Junseo Lee *et al.**
+
+**TL;DR** — Delivers an end-to-end autotuning framework that jointly optimizes compiler flags, runtime parameters, and problem-specific configurations for HPC applications through structured search.
+
+**Why notable** — Manual tuning of HPC codes for new architectures is expensive and error-prone; HYPERF's end-to-end scope distinguishes it from prior tools that target only one layer of the software stack, offering broader applicability across the HPC software ecosystem.
+
+[→ Read paper](https://doi.org/10.1145/3731545.3731588)
+
+---
+
+### Efficient and Cost-Effective HPC on the Cloud
+
+*Aditya Bhosale, Laxmikant V. Kalé, Sara Kokkila Schumacher*
+
+**TL;DR** — Demonstrates how Charm++-based adaptive runtime techniques—load balancing, dynamic over-decomposition, and message-driven execution—can recover near-on-premises HPC performance on cloud instances despite higher network variability.
+
+**Why notable** — Cloud-HPC convergence is a major community priority as on-premises clusters face procurement delays; this paper provides a practitioner-oriented analysis of which runtime adaptations deliver the best performance-per-dollar on AWS and Azure.
+
+[→ Read paper](https://doi.org/10.1145/3731545.3744667)
+
+---
+
+### Bringing Differential Privacy to HPC: Privacy-Preserving Transformations of HPC Traces
+
+*Ana Luisa Veroneze Solórzano, Rohan Basu Roy, Benjamin Schwaller, Sara Petra Walton *et al.**
+
+**TL;DR** — Applies differential privacy mechanisms to HPC job and performance traces, enabling centers to share workload data for research without exposing sensitive user or application information.
+
+**Why notable** — Sharing HPC traces is critical for reproducible scheduling and performance research but is often blocked by privacy concerns; this work provides a rigorous, deployable solution that could unlock a significant new supply of public HPC datasets.
+
+[→ Read paper](https://doi.org/10.1145/3731545.3731573)
+

site/content/cloud-edge/digests/HPDC-2026/index.md

@@ -0,0 +1,13 @@
+---
+title: HPDC 2026 Digest
+venue: HPDC
+year: 2026
+date: '2026-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/IC-2024/index.md

@@ -0,0 +1,112 @@
+---
+title: IC 2024 Digest
+venue: IC
+year: 2024
+date: '2024-01-01'
+tags: []
+paper_count: 10
+draft: false
+---
+
+10 papers selected.
+
+---
+
+### Revisiting Edge AI: Opportunities and Challenges
+
+*Tobias Meuser, Lauri Lovén, Monowar Bhuyan, Shishir G. Patil *et al.**
+
+**TL;DR** — A multi-author position paper that revisits the state of edge AI, cataloguing deployment barriers and open research problems across hardware, networking, and software layers.
+
+**Why notable** — Brings together 19 leading researchers to synthesize the field's most pressing edge AI challenges, making it an authoritative reference for practitioners and researchers planning edge deployments.
+
+---
+
+### On Causality in Distributed Continuum Systems
+
+*Víctor Casamayor-Pujol, Boris Sedlak, Praveen Kumar Donta, Schahram Dustdar*
+
+**TL;DR** — Formalizes causal reasoning across cloud-to-edge continuum systems, providing a conceptual framework for tracking cause-and-effect relationships in highly distributed deployments.
+
+**Why notable** — Addresses a foundational gap in distributed systems theory that becomes critical when debugging or optimizing multi-tier edge–cloud pipelines.
+
+---
+
+### Beyond Von Neumann in the Computing Continuum: Architectures, Applications, and Future Directions
+
+*Dragi Kimovski, Nishant Saurabh, Matthijs Jansen, Atakan Aral *et al.**
+
+**TL;DR** — Surveys non-von Neumann architectural paradigms—neuromorphic, in-memory, and dataflow computing—and maps them onto continuum computing use cases spanning edge to cloud.
+
+**Why notable** — Offers a rare cross-cutting view of how emerging hardware architectures reshape the design space for distributed Internet applications.
+
+---
+
+### ARASEC: Adaptive Resource Allocation and Model Training for Serverless Edge-Cloud Computing
+
+*Dewant Katare, Eduard Marin, Nicolas Kourtellis, Marijn Janssen *et al.**
+
+**TL;DR** — Proposes ARASEC, a system that jointly optimizes resource allocation and on-device model training for serverless functions deployed across edge and cloud nodes.
+
+**Why notable** — Demonstrates measurable efficiency gains in a realistic serverless edge-cloud setting, directly informing how operators should provision heterogeneous serverless infrastructure.
+
+---
+
+### WebAssembly at the Edge: Benchmarking a Serverless Platform for Private Edge Cloud Systems
+
+*Giuseppe De Palma, Saverio Giallorenzo, Jacopo Mauro, Matteo Trentin *et al.**
+
+**TL;DR** — Benchmarks a WebAssembly-based serverless runtime on private edge cloud hardware, measuring cold-start latency, throughput, and isolation overhead compared to container-based alternatives.
+
+**Why notable** — Provides concrete empirical data that practitioners need when evaluating WebAssembly as a lightweight alternative to Docker for edge serverless deployments.
+
+---
+
+### HeROsim: An Allocation and Scheduling Simulator for Evaluating Serverless Orchestration Policies
+
+*Vincent Lannurien, Laurent d'Orazio, Olivier Barais, Stéphane Paquelet *et al.**
+
+**TL;DR** — Introduces HeROsim, an open simulator that models serverless function placement and scheduling policies across heterogeneous infrastructure, enabling fair policy comparison without live cluster costs.
+
+**Why notable** — Fills a practical tooling gap for researchers and platform engineers who need reproducible evaluation environments for serverless orchestration algorithms.
+
+---
+
+### Hierarchical Network Data Analytics Framework for 6G Network Automation: Design and Implementation
+
+*Youbin Jeon, Sangheon Pack*
+
+**TL;DR** — Designs and implements a hierarchical analytics framework that aggregates network telemetry at multiple granularities to automate management decisions in 6G deployments.
+
+**Why notable** — Bridges the gap between 6G vision and practical automation by providing a concrete architecture with implementation details and empirical evaluation.
+
+---
+
+### Digital-Twin-Driven End-to-End Network Slicing Toward 6G
+
+*Mahnoor Yaqoob, Ramona Trestian, Mallik Tatipamula, Huan Xuan Nguyen*
+
+**TL;DR** — Proposes a digital-twin framework that continuously models and reconfigures end-to-end network slices, enabling dynamic SLA enforcement across heterogeneous 6G infrastructure.
+
+**Why notable** — Connects digital twin technology to the operational problem of network slice management, a key requirement for 6G service assurance.
+
+---
+
+### The Internet of Things in the Era of Generative AI: Vision and Challenges
+
+*Xin Wang 0120, Zhongwei Wan, Arvin Hekmati, Mingyu Zong *et al.**
+
+**TL;DR** — Examines how generative AI models can be integrated into IoT pipelines for data synthesis, anomaly detection, and on-device inference, and identifies the key resource and privacy constraints.
+
+**Why notable** — Provides a structured research agenda for one of the most active intersections in Internet computing, relevant to both IoT platform designers and ML practitioners.
+
+---
+
+### Distributed Federated Deep Learning in Clustered Internet of Things Wireless Networks With Data Similarity-Based Client Participation
+
+*Evangelia Fragkou 0001, Eleftheria Chini, Maria Papadopoulou 0008, Dimitrios K. Papakostas *et al.**
+
+**TL;DR** — Proposes a clustered federated learning scheme for wireless IoT networks that selects participating clients based on data similarity, reducing communication overhead and improving model convergence.
+
+**Why notable** — Addresses a core practical challenge in IoT federated learning—heterogeneous and non-IID data—with an empirically validated participation strategy.
+

site/content/cloud-edge/digests/IC-2025/index.md

@@ -0,0 +1,112 @@
+---
+title: IC 2025 Digest
+venue: IC
+year: 2025
+date: '2025-01-01'
+tags: []
+paper_count: 10
+draft: false
+---
+
+10 papers selected.
+
+---
+
+### Rethinking Computing Systems in the Era of Climate Crisis: A Call for a Sustainable Computing Continuum
+
+*Ella Peltonen, Suzan Bayhan, David Bermbach, Sebastian Buschjäger *et al.**
+
+**TL;DR** — A multi-author position paper calling for carbon-aware design principles across the cloud-to-edge computing continuum, surveying energy measurement, workload scheduling, and hardware lifecycle challenges.
+
+**Why notable** — Establishes a community research agenda for sustainable computing infrastructure at a time when datacenter and edge energy consumption is under increasing regulatory and societal scrutiny.
+
+---
+
+### Toward Carbon-Aware Data Transfers
+
+*Jacob Goldverg, Hasibul Jamil, Elvis Rodrigues, Tevfik Kosar*
+
+**TL;DR** — Proposes scheduling and routing strategies for large-scale data transfers that minimize carbon emissions by leveraging time- and location-varying grid carbon intensity signals.
+
+**Why notable** — Delivers a practical, implementable mechanism for reducing the carbon footprint of Internet data movement, directly applicable to data-intensive scientific and cloud workflows.
+
+---
+
+### Zero Trust-Driven Collaborative Intrusion Detection in Internet of Things: A Continuous Trust Assessment Approach
+
+*Xinxin Wang, Qingjun Yuan, Yongjuan Wang, Jihong Teng *et al.**
+
+**TL;DR** — Designs a collaborative intrusion detection system for IoT networks grounded in zero-trust principles, continuously reassessing device trust scores to isolate compromised nodes in real time.
+
+**Why notable** — Demonstrates how zero-trust architectures can be operationalized at IoT scale, providing a concrete detection model with empirical evaluation on real traffic.
+
+---
+
+### Securing Voice Authentication Applications Against Targeted Data Poisoning
+
+*Alireza Mohammadi, Keshav Sood, Asef Nazari, Dhananjay R. Thiruvady*
+
+**TL;DR** — Identifies and mitigates targeted data poisoning attacks on voice authentication systems by detecting and filtering malicious training samples before model updates are applied.
+
+**Why notable** — Highlights a practical and underexplored attack surface in biometric authentication services, with defenses validated against realistic adversarial scenarios.
+
+---
+
+### Characterization of Probabilistic Structure of Internet Traffic During COVID-19: A Study Based on MAWI Data
+
+*Anoushka Mittal, Pranav Jain, Karmeshu, Shachi Sharma*
+
+**TL;DR** — Applies statistical modeling to MAWI backbone traffic traces collected during COVID-19 to characterize shifts in Internet traffic distributions and identify new usage patterns.
+
+**Why notable** — Provides rare longitudinal empirical evidence of how a major societal disruption altered Internet traffic structure, with implications for capacity planning and anomaly detection baselines.
+
+---
+
+### iGenEdge: Intelligent Generative AI Service Deployment for Edge-Connected IoT Devices
+
+*Faiza Akram, Asad Waqar Malik, Samee U. Khan*
+
+**TL;DR** — Proposes iGenEdge, a framework that intelligently partitions and deploys generative AI inference tasks across edge servers and IoT devices based on latency, energy, and model accuracy constraints.
+
+**Why notable** — Addresses the critical engineering challenge of running large generative models close to IoT data sources, with practical placement algorithms and experimental validation.
+
+---
+
+### Smaller, Smarter, Closer: The Edge of Collaborative Generative Artificial Intelligence
+
+*Roberto Morabito, SiYoung Jang*
+
+**TL;DR** — Surveys strategies for deploying collaborative generative AI models at the network edge, covering model compression, offloading, and inter-device coordination techniques.
+
+**Why notable** — Gives a clear-eyed assessment of where edge generative AI stands today and what infrastructure advances are needed, serving as a practical guide for edge platform designers.
+
+---
+
+### Memory-Augmented Autoencoder with Reservoir Computing for Edge-Based Anomaly Detection in Autonomous Systems
+
+*Fabiha Nowshin, Zheng Dong 0002, Yang Yi 0002*
+
+**TL;DR** — Combines a memory-augmented autoencoder with reservoir computing to detect anomalies in autonomous system sensor streams directly on resource-constrained edge hardware.
+
+**Why notable** — Demonstrates strong anomaly detection accuracy under tight edge compute budgets, making it directly relevant to safety-critical IoT and autonomous vehicle deployments.
+
+---
+
+### Ship-to-Shore Network Monitoring: The Research Vessel Sikuliaq Experience
+
+*Komal Thareja, Anirban Mandal, Julian Race, Paul Ruth *et al.**
+
+**TL;DR** — Presents a real-world case study of continuous network monitoring for a research vessel operating over satellite links, characterizing link quality, disruptions, and measurement methodology.
+
+**Why notable** — Offers rare empirical data on challenged maritime Internet connectivity, informing the design of resilient monitoring and science workflows for remote and mobile environments.
+
+---
+
+### Think Locally, Act Globally: A Programming Model for Decentralized Applications
+
+*Julian Haas, Christian Kuessner, Ragnar Mogk, Mira Mezini*
+
+**TL;DR** — Introduces a programming model that lets developers write local per-node logic while the runtime automatically enforces global consistency and coordination across a decentralized application.
+
+**Why notable** — Tackles the fundamental complexity of building correct decentralized Internet applications, offering a principled abstraction that could reduce the gap between distributed systems theory and practice.
+

site/content/cloud-edge/digests/IC-2026/index.md

@@ -0,0 +1,13 @@
+---
+title: IC 2026 Digest
+venue: IC
+year: 2026
+date: '2026-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/IPDPS-2024/index.md

@@ -0,0 +1,124 @@
+---
+title: IPDPS 2024 Digest
+venue: IPDPS
+year: 2024
+date: '2024-01-01'
+tags: []
+paper_count: 14
+draft: false
+---
+
+14 papers selected.
+
+---
+
+### Low-Depth Spatial Tree Algorithms
+
+*Yves Baumann, Tal Ben-Nun, Maciej Besta, Lukas Gianinazzi *et al.**
+
+**TL;DR** — Introduces parallel spatial-tree algorithms with provably low depth, advancing the theory of work-efficient parallel data structures for geometric workloads.
+
+---
+
+### Alternative Basis Matrix Multiplication is Fast and Stable
+
+*Oded Schwartz, Sivan Toledo, Noa Vaknin, Gal Wiernik*
+
+**TL;DR** — Demonstrates that alternative-basis matrix multiplication achieves both practical speed and numerical stability, challenging the conventional trade-off between the two.
+
+---
+
+### Wait-free Trees with Asymptotically-Efficient Range Queries
+
+*Ilya Kokorin, Victor Yudov, Vitaly Aksenov, Dan Alistarh*
+
+**TL;DR** — Presents the first wait-free balanced search tree supporting asymptotically optimal range queries, a long-standing open problem in concurrent data structures.
+
+---
+
+### Parallel Derandomization for Coloring
+
+*Sam Coy, Artur Czumaj, Peter Davies-Peck, Gopinath Mishra*
+
+**TL;DR** — Develops deterministic parallel graph-coloring algorithms via derandomization, closing a key gap between randomized and deterministic complexity in this foundational problem.
+
+---
+
+### HINT: Designing Cache-Efficient MPI_Alltoall using Hybrid Memory Copy Ordering and Non-Temporal Instructions
+
+*Bharath Ramesh 0005, Nick Contini, Nawras Alnaasan, Kaushik Kandadi Suresh *et al.**
+
+**TL;DR** — Achieves substantial MPI_Alltoall bandwidth improvements by combining cache-aware copy ordering with non-temporal store instructions, directly benefiting large-scale collective communication.
+
+---
+
+### An Optimized Error-controlled MPI Collective Framework Integrated with Lossy Compression
+
+*Jiajun Huang 0001, Sheng Di, Xiaodong Yu 0001, Yujia Zhai *et al.**
+
+**TL;DR** — Integrates error-bounded lossy compression directly into MPI collectives, reducing communication volume with provable accuracy guarantees for HPC scientific applications.
+
+---
+
+### Software Resource Disaggregation for HPC with Serverless Computing
+
+*Marcin Copik, Marcin Chrapek, Larissa Schmid, Alexandru Calotoiu *et al.**
+
+**TL;DR** — Shows that serverless computing can serve as a practical resource-disaggregation layer for HPC, enabling fine-grained elasticity without sacrificing performance.
+
+---
+
+### Tackling Cold Start in Serverless Computing with Multi-Level Container Reuse
+
+*Amelie Chi Zhou, Rongzheng Huang, Zhoubin Ke, Yusen Li *et al.**
+
+**TL;DR** — Proposes a multi-level container-reuse strategy that significantly reduces cold-start latency in serverless platforms, addressing one of the main performance bottlenecks.
+
+---
+
+### LightDAG: A Low-latency DAG-based BFT Consensus through Lightweight Broadcast
+
+*Xiaohai Dai, Guanxiong Wang, Jiang Xiao 0001, Zhengxuan Guo *et al.**
+
+**TL;DR** — Redesigns DAG-based Byzantine fault-tolerant consensus to use lightweight broadcast, cutting latency while preserving safety and liveness in distributed systems.
+
+---
+
+### Benchmarking and Dissecting the Nvidia Hopper GPU Architecture
+
+*Weile Luo, Ruibo Fan, Zeyu Li, Dayou Du *et al.**
+
+**TL;DR** — Provides the first systematic microbenchmark characterization of Hopper's new hardware features (TMA, warpgroup MMA, NVLink-4), yielding actionable insights for kernel developers.
+
+---
+
+### DEFCON: Deformable Convolutions Leveraging Interval Search and GPU Texture Hardware
+
+*Malith Jayaweera, Yanyu Li, Yanzhi Wang 0001, Bin Ren 0002 *et al.**
+
+**TL;DR** — Exploits GPU texture-cache hardware to accelerate deformable convolutions, delivering significant speedups over cuDNN-based baselines for irregular memory-access patterns.
+
+---
+
+### nOS-V: Co-Executing HPC Applications Using System-Wide Task Scheduling
+
+*David Álvarez 0006, Kevin Sala, Vicenç Beltran 0001*
+
+**TL;DR** — Introduces a system-wide task scheduler that safely co-executes multiple HPC applications on shared hardware, improving cluster utilization without modifying application code.
+
+---
+
+### Hadar: Heterogeneity-Aware Optimization-Based Online Scheduling for Deep Learning Cluster
+
+*Abeda Sultana, Fei Xu, Xu Yuan 0001, Li Chen 0019 *et al.**
+
+**TL;DR** — Formulates deep-learning cluster scheduling as an online optimization problem that explicitly accounts for GPU heterogeneity, reducing job completion times and improving fairness.
+
+---
+
+### A Parallel Partial Merge Repair Algorithm for Multi-block Failures for Erasure Storage Systems
+
+*Shuaipeng Zhang, Shiyi Li, Chentao Wu, Ruobin Wu *et al.**
+
+**TL;DR** — Presents a parallel repair algorithm for simultaneous multi-block erasure failures that outperforms sequential recovery while reducing I/O and computational overhead.
+

site/content/cloud-edge/digests/IPDPS-2025/index.md

@@ -0,0 +1,160 @@
+---
+title: IPDPS 2025 Digest
+venue: IPDPS
+year: 2025
+date: '2025-05-19'
+tags:
+- parallel-computing
+- hpc
+- distributed-systems
+- gpu
+paper_count: 12
+draft: false
+---
+
+12 papers selected.
+
+---
+
+### Enhancing OmpSs-2 Suspendable Tasks by Combining Operating System and User-Level Threads with C++ Coroutines
+
+*Arnau Cinca, Aleix Roca, Kevin Sala, Raúl Peñacoba Veigas *et al.**
+
+**TL;DR** — Extends the OmpSs-2 task-based runtime with C++ coroutines to implement suspendable tasks that can yield while blocked on I/O or communication without stalling the OS thread.
+
+**Why notable** — Suspendable tasks are a key missing primitive for overlapping computation and communication in task-graph runtimes; the hybrid OS/user-level thread design avoids the overhead of full context switches while remaining portable, with broad implications for OpenMP-style programming on modern heterogeneous nodes.
+
+[→ Read paper](https://doi.org/10.1109/IPDPS64566.2025.00015)
+
+---
+
+### PISA: An Adversarial Approach to Comparing Task Graph Scheduling Algorithms
+
+*Jared Coleman, Bhaskar Krishnamachari*
+
+**TL;DR** — Introduces an adversarial instance-generation framework that automatically synthesizes task graphs that expose worst-case performance gaps between competing scheduling heuristics.
+
+**Why notable** — Benchmark-driven comparison of DAG schedulers is notoriously biased toward whoever designed the benchmark; PISA's adversarial synthesis provides a principled, algorithm-agnostic methodology that could become a standard evaluation tool for the task-scheduling community.
+
+[→ Read paper](https://doi.org/10.1109/IPDPS64566.2025.00014)
+
+---
+
+### Parallel Scheduling of Task Graphs with Minimal Memory Requirements
+
+*Pascal Fradet, Alain Girault, Alexandre Honorat*
+
+**TL;DR** — Proves tight bounds and provides scheduling algorithms for task graphs that minimize peak memory usage while preserving parallelism, targeting memory-constrained accelerators.
+
+**Why notable** — Peak memory is increasingly the binding constraint on accelerators with fixed HBM capacity; deriving schedules that are jointly memory-optimal and parallel addresses a theoretically hard trade-off that directly impacts large-scale neural network and sparse-solver pipelines.
+
+[→ Read paper](https://doi.org/10.1109/IPDPS64566.2025.00042)
+
+---
+
+### FATHOM: Fast Attention Through Optimizing Memory
+
+*Elliott Binder, Arvind Sudarsanam, Ravi Sunkavalli, Tze Meng Low*
+
+**TL;DR** — Redesigns the attention kernel memory access pattern to maximize reuse across the Q, K, and V tiles, achieving significant throughput gains over FlashAttention on modern GPUs.
+
+**Why notable** — Attention is the dominant compute bottleneck in transformer inference and training; FATHOM's memory-centric reformulation improves on the widely deployed FlashAttention baseline and demonstrates that analytical cache-tile reasoning still yields practical gains at scale.
+
+[→ Read paper](https://doi.org/10.1109/IPDPS64566.2025.00106)
+
+---
+
+### Fast and Effective Lossy Compression on GPUs and CPUs with Guaranteed Error Bounds
+
+*Alex Fallin, Noushin Azami, Sheng Di, Franck Cappello *et al.**
+
+**TL;DR** — Presents a portable error-bounded lossy compressor that runs natively on both GPU and CPU, delivering competitive compression ratios with strict point-wise error guarantees and low latency.
+
+**Why notable** — Scientific simulations increasingly need in-situ compression on the same GPU that runs the simulation; providing tight error bounds alongside GPU portability bridges a critical gap between scientific fidelity requirements and storage bandwidth constraints at exascale.
+
+[→ Read paper](https://doi.org/10.1109/IPDPS64566.2025.00083)
+
+---
+
+### Phase-Based Frequency Scaling for Energy-Efficient Heterogeneous Computing
+
+*Lorenzo Carpentieri, Antonio De Caro, Majid Salimi Beni, Kaijie Fan *et al.**
+
+**TL;DR** — Dynamically scales CPU and GPU frequencies based on detected application phases to reduce energy consumption while preserving performance on heterogeneous nodes.
+
+**Why notable** — Energy efficiency is a first-class constraint at exascale; phase-aware DVFS that jointly controls both CPU and GPU frequencies avoids the over-provisioning inherent in static policies, with measured gains directly applicable to production HPC clusters.
+
+[→ Read paper](https://doi.org/10.1109/IPDPS64566.2025.00078)
+
+---
+
+### HiCCL: A Hierarchical Collective Communication Library
+
+*Mert Hidayetoglu, Simon Garcia de Gonzalo, Elliott Slaughter, Pinku Surana *et al.**
+
+**TL;DR** — Implements a multi-level collective communication library that decomposes all-reduce and other collectives into hierarchical sub-collectives matched to node-local, intra-rack, and inter-rack bandwidth tiers.
+
+**Why notable** — Flat NCCL/MPI collectives ignore the hierarchical bandwidth structure of modern GPU clusters; HiCCL's topology-aware decomposition achieves substantial throughput improvements on large distributed training jobs and is designed to be backend-agnostic.
+
+[→ Read paper](https://doi.org/10.1109/IPDPS64566.2025.00089)
+
+---
+
+### Unified Designs of Multi-Rail-Aware MPI Allreduce and Alltoall Operations Across Diverse GPU and Interconnect Systems
+
+*Chen-Chun Chen, Jinghan Yao, Lang Xu, Hari Subramoni *et al.**
+
+**TL;DR** — Develops unified multi-rail-aware algorithms for MPI Allreduce and Alltoall that exploit all available NIC ports simultaneously across heterogeneous interconnect systems.
+
+**Why notable** — Multi-rail configurations are increasingly common in HPC clusters yet most MPI libraries treat them as a single logical link; this work systematically closes the performance gap and the unified design enables deployment without per-system hand-tuning.
+
+[→ Read paper](https://doi.org/10.1109/IPDPS64566.2025.00088)
+
+---
+
+### CoRD: Converged RDMA Dataplane
+
+*Maksym Planeta, Jan Bierbaum, Michael Roitzsch, Hermann Härtig*
+
+**TL;DR** — Proposes a converged RDMA dataplane that unifies one-sided and two-sided communication semantics over a single kernel-bypass path, reducing software overhead and improving scalability.
+
+**Why notable** — RDMA stacks remain split between one-sided verbs and two-sided message passing, forcing application writers to choose and preventing optimal use of NIC offload capabilities; CoRD's converged abstraction enables a new class of communication patterns at near-wire speed.
+
+[→ Read paper](https://doi.org/10.1109/IPDPS64566.2025.00099)
+
+---
+
+### FlexRLHF: A Flexible Placement and Parallelism Framework for Efficient RLHF Training
+
+*Youshao Xiao, Zhenglei Zhou, Fagui Mao, Weichang Wu *et al.**
+
+**TL;DR** — Introduces a placement and parallelism co-optimization framework for Reinforcement Learning from Human Feedback (RLHF) training that jointly schedules the actor, critic, and reward models to maximize GPU utilization.
+
+**Why notable** — RLHF is the dominant fine-tuning paradigm for large language models but its multi-model, heterogeneous-workload structure makes naive data/model parallelism highly inefficient; FlexRLHF's co-placement approach delivers meaningful throughput gains and establishes a design template for future RLHF infrastructure.
+
+[→ Read paper](https://doi.org/10.1109/IPDPS64566.2025.00039)
+
+---
+
+### GuardianOMP: A Framework for Highly Productive Fault Tolerance Via OpenMP Task-Level Replication
+
+*Adrian Munera, Eduardo Quiñones, Sara Royuela*
+
+**TL;DR** — Adds transparent task-level redundant execution to OpenMP applications, enabling automatic detection and recovery from silent data corruption without application source changes.
+
+**Why notable** — Silent data corruption is an escalating concern as DRAM and compute elements scale into billions of transistors; GuardianOMP's integration at the OpenMP runtime level makes resilience accessible to the broad HPC community that already uses OpenMP without requiring manual checkpoint/restart logic.
+
+[→ Read paper](https://doi.org/10.1109/IPDPS64566.2025.00114)
+
+---
+
+### Tera-Scale Multilevel Graph Partitioning
+
+*Daniel Salwasser, Daniel Seemaier, Lars Gottesbüren, Peter Sanders 0001*
+
+**TL;DR** — Scales multilevel graph partitioning to trillion-edge graphs through a distributed coarsening and refinement pipeline that maintains partition quality competitive with state-of-the-art tools on billion-edge benchmarks.
+
+**Why notable** — Graph partitioning is a prerequisite for almost every distributed graph workload; reaching the tera-scale regime with near-optimal quality is a significant algorithmic and engineering milestone that directly enables graph-parallel simulation at the largest current HPC scales.
+
+[→ Read paper](https://doi.org/10.1109/IPDPS64566.2025.00033)
+

site/content/cloud-edge/digests/IPDPS-2026/index.md

@@ -0,0 +1,13 @@
+---
+title: IPDPS 2026 Digest
+venue: IPDPS
+year: 2026
+date: '2026-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/JPDC-2024/index.md

@@ -0,0 +1,132 @@
+---
+title: JPDC 2024 Digest
+venue: JPDC
+year: 2024
+date: '2024-01-01'
+tags: []
+paper_count: 12
+draft: false
+---
+
+12 papers selected.
+
+---
+
+### Read/write fence-free work-stealing with multiplicity
+
+*Armando Castañeda, Miguel Piña*
+
+**TL;DR** — Presents a work-stealing deque algorithm that eliminates read/write memory fences while tolerating multiplicity, achieving provably correct concurrent access without costly barriers.
+
+**Why notable** — Advances the theoretical foundations of lock-free scheduler data structures by decoupling correctness from fence instructions, directly impacting runtime system design.
+
+---
+
+### Reliable communication in dynamic networks with locally bounded byzantine faults
+
+*Silvia Bonomi, Giovanni Farina, Sébastien Tixeuil*
+
+**TL;DR** — Characterizes the conditions under which reliable broadcast is achievable in dynamic networks where Byzantine faults are locally bounded rather than globally counted.
+
+**Why notable** — Provides tight impossibility and achievability results for a practically motivated fault model, extending classical Byzantine agreement theory to time-varying topologies.
+
+---
+
+### Local certification of graph decompositions and applications to minor-free classes
+
+*Nicolas Bousquet 0001, Laurent Feuilloley, Théo Pierron*
+
+**TL;DR** — Develops local distributed certification schemes for graph decompositions, proving tight certificate-size bounds for minor-free graph families.
+
+**Why notable** — Connects structural graph theory to distributed verification, giving new tools for designing space-efficient proof-labeling schemes in anonymous networks.
+
+---
+
+### Eventually lattice-linear algorithms
+
+*Arya Tanmay Gupta, Sandeep S. Kulkarni*
+
+**TL;DR** — Introduces the eventually lattice-linear class of distributed algorithms that converge to a lattice-linear fixed point, enabling new self-stabilization constructions.
+
+**Why notable** — Unifies several stabilizing algorithm families under a clean algebraic framework that simplifies correctness proofs and inspires new design patterns.
+
+---
+
+### Construction algorithms of fault-tolerant paths and disjoint paths in k-ary n-cube networks
+
+*Mengjie Lv, Jianxi Fan, Baolei Cheng, Jia Yu 0003 *et al.**
+
+**TL;DR** — Proposes efficient algorithms to construct maximally fault-tolerant Hamiltonian paths and node-disjoint paths in k-ary n-cube interconnection networks under edge and vertex failures.
+
+**Why notable** — Yields concrete routing strategies for torus-based HPC fabrics that remain functional under high fault counts, with tight proofs of optimality.
+
+---
+
+### MapReduce algorithms for robust center-based clustering in doubling metrics
+
+*Enrico Dandolo, Alessio Mazzetto, Andrea Pietracaprina, Geppino Pucci*
+
+**TL;DR** — Designs MapReduce algorithms for k-median and k-means clustering with provable approximation ratios that are robust to outliers in doubling metric spaces.
+
+**Why notable** — Delivers the first round-efficient MapReduce clustering algorithms with simultaneous robustness and approximation guarantees grounded in metric space theory.
+
+---
+
+### DuMato: An efficient warp-centric subgraph enumeration system for GPU
+
+*Samuel Ferraz, Vinícius Vitor dos Santos Dias, Carlos H. C. Teixeira, Srinivasan Parthasarathy 0001 *et al.**
+
+**TL;DR** — Presents a warp-centric GPU programming model for subgraph enumeration that eliminates load imbalance through dynamic work redistribution across warps.
+
+**Why notable** — Achieves orders-of-magnitude speedups over CPU baselines on graph pattern mining by rethinking how irregular workloads are mapped onto SIMT hardware.
+
+---
+
+### An efficient sequential consistency implementation with dynamic race detection for GPUs
+
+*Abdulaziz Tabbakh, Murali Annavaram*
+
+**TL;DR** — Implements sequential consistency on GPUs via a dynamic race detector that inserts fences only where data races are actually detected at runtime.
+
+**Why notable** — Shows that strong memory model guarantees on GPUs need not incur pervasive overhead, opening a path toward safer GPU programming models without sacrificing performance.
+
+---
+
+### General-purpose data stream processing on heterogeneous architectures with WindFlow
+
+*Gabriele Mencagli, Massimo Torquati, Dalvan Griebler, Alessandra Fais *et al.**
+
+**TL;DR** — Extends the WindFlow library with a unified programming model and runtime that transparently targets CPUs, GPUs, and FPGAs for streaming dataflow applications.
+
+**Why notable** — Demonstrates practical performance portability for stream processing across radically different hardware, with a clean operator model grounded in parallel patterns theory.
+
+---
+
+### Revisiting I/O bandwidth-sharing strategies for HPC applications
+
+*Anne Benoit, Thomas Hérault, Lucas Perotin, Yves Robert *et al.**
+
+**TL;DR** — Analyzes optimal I/O bandwidth allocation policies for HPC checkpointing and data-intensive applications under shared storage systems, deriving scheduling algorithms with provable performance bounds.
+
+**Why notable** — Provides theoretically grounded guidance for I/O resource management at scale, a pervasive bottleneck in modern HPC deployments.
+
+---
+
+### Scalable atomic broadcast: A leaderless hierarchical algorithm
+
+*Lucas V. Ruchel, Edson Tavares de Camargo, Luiz Antonio Rodrigues, Rogério C. Turchetti *et al.**
+
+**TL;DR** — Proposes a leaderless hierarchical atomic broadcast protocol that eliminates single-leader bottlenecks and scales to large distributed systems with reduced message complexity.
+
+**Why notable** — Advances Byzantine-fault-tolerant broadcast by removing the leader as a scalability and availability bottleneck while preserving total-order guarantees.
+
+---
+
+### Stab-FD: A cooperative and adaptive failure detector for wide area networks
+
+*Pierre Sens 0001, Luciana Arantes, Anubis Graciela de Moraes Rossetto, Olivier Marin*
+
+**TL;DR** — Presents a stabilizing failure detector that cooperatively adapts its timeout parameters across WAN nodes to achieve eventual accuracy under varying latencies.
+
+**Why notable** — Tackles the long-standing challenge of practical failure detection in geo-distributed systems with a rigorous self-stabilizing design that avoids static parameter tuning.
+

site/content/cloud-edge/digests/JPDC-2025/index.md

@@ -0,0 +1,132 @@
+---
+title: JPDC 2025 Digest
+venue: JPDC
+year: 2025
+date: '2025-01-01'
+tags: []
+paper_count: 12
+draft: false
+---
+
+12 papers selected.
+
+---
+
+### Throughput of Byzantine Broadcast
+
+*Ruomu Hou, Haifeng Yu, Prateek Saxena*
+
+**TL;DR** — Establishes tight throughput bounds for Byzantine broadcast protocols and constructs algorithms that saturate those bounds, separating throughput from latency in the fault-tolerant broadcast landscape.
+
+**Why notable** — Provides the first rigorous throughput characterization of Byzantine broadcast, a fundamental primitive whose capacity limits were previously unquantified.
+
+---
+
+### How to reduce the number of steps for (multi-valued validated) Byzantine agreement?
+
+*Baohan Huang, Haibin Zhang, Chao Liu 0039, Shengli Liu 0001 *et al.**
+
+**TL;DR** — Presents new Byzantine agreement protocols that lower the step complexity for multi-valued and validated variants, breaking barriers that have stood since the classical results.
+
+**Why notable** — Step complexity is a fundamental metric for distributed agreement; reducing it has direct implications for consensus latency in blockchains and replicated systems.
+
+---
+
+### Locating a black hole in a dynamic ring
+
+*Giuseppe Antonio Di Luna, Paola Flocchini, Giuseppe Prencipe, Nicola Santoro*
+
+**TL;DR** — Solves the black-hole search problem on rings whose topology changes over time, establishing the agent and time complexity of locating a fatal node in a dynamic distributed environment.
+
+**Why notable** — Extends a classic distributed exploration problem to dynamic graphs, requiring new algorithmic techniques that are broadly applicable to fault detection in evolving networks.
+
+---
+
+### Dispersion of mobile robots on directed anonymous graphs
+
+*Giuseppe F. Italiano, Debasish Pattanayak, Gokarna Sharma*
+
+**TL;DR** — Characterizes the necessary and sufficient conditions for a group of mobile robots to disperse to distinct nodes of a directed anonymous graph, and provides optimal algorithms.
+
+**Why notable** — Directed anonymous graphs model asymmetric communication networks; the dispersion problem's resolution here advances the theory of autonomous distributed agents.
+
+---
+
+### QPOPSS: Query and Parallelism Optimized Space-Saving for finding frequent stream elements
+
+*Victor Jarlow, Charalampos Stylianopoulos, Marina Papatriantafilou*
+
+**TL;DR** — Redesigns the Space-Saving frequent-elements sketch for concurrent shared-memory execution, achieving high query throughput alongside update throughput without sacrificing approximation accuracy.
+
+**Why notable** — Bridges the gap between approximate streaming data structures and parallel execution, demonstrating that heavy-hitter summaries can scale on multicore without significant accuracy loss.
+
+---
+
+### A parallel algorithm for minimum weight set cover with small neighborhood property
+
+*Yingli Ran, Yaoyao Zhang, Zhao Zhang 0002*
+
+**TL;DR** — Gives a parallel approximation algorithm for minimum weight set cover instances where sets have bounded neighborhood size, achieving near-optimal approximation ratio in poly-logarithmic rounds.
+
+**Why notable** — Expands the frontier of problems admitting efficient parallel approximation, with implications for distributed network optimization where local structure can be exploited.
+
+---
+
+### Optimizing parallel heterogeneous system efficiency: Dynamic task graph adaptation with recursive tasks
+
+*Nathalie Furmento, Abdou Guermouche, Gwenolé Lucas, Thomas Morin *et al.**
+
+**TL;DR** — Extends task-graph runtime systems to support recursive task generation, enabling dynamic adaptation of the task graph structure to improve load balance on heterogeneous CPU-GPU platforms.
+
+**Why notable** — Recursive task parallelism is essential for divide-and-conquer workloads; integrating it into heterogeneous runtimes closes a major gap in practical parallel programming models.
+
+---
+
+### A scheduler to foster data locality for GPU and out-of-core task-based linear algebra applications
+
+*Maxime Gonthier, Loris Marchal, Samuel Thibault*
+
+**TL;DR** — Proposes a data-locality-aware scheduler for task-based dense linear algebra that simultaneously manages GPU memory and out-of-core data transfers to minimize data movement.
+
+**Why notable** — Data movement dominates cost in large linear algebra computations; the scheduler's dual handling of GPU memory and disk I/O makes it practically relevant for exascale workloads.
+
+---
+
+### Leveraging Multi-Instance GPUs through moldable task scheduling
+
+*Jorge Villarrubia, Luis Costero, Francisco D. Igual, Katzalin Olcoz*
+
+**TL;DR** — Develops a moldable task scheduling framework that dynamically partitions GPU compute across concurrent tasks using NVIDIA's Multi-Instance GPU feature to improve overall throughput.
+
+**Why notable** — MIG is a critical hardware feature for multi-tenant GPU clusters; this work provides the first scheduling framework that exploits it through principled moldable-task theory.
+
+---
+
+### Integration framework for online thread throttling with thread and page mapping on NUMA systems
+
+*Janaina Schwarzrock, Hiago Mayk G. de A. Rocha, Arthur Francisco Lorenzon, Samuel Xavier de Souza *et al.**
+
+**TL;DR** — Combines online thread-count throttling with NUMA-aware thread and page placement in a unified runtime framework, adaptively co-optimizing both dimensions to maximize performance.
+
+**Why notable** — Thread throttling and NUMA placement are typically managed independently; their joint online optimization yields measurable gains that neither technique alone achieves.
+
+---
+
+### To repair or not to repair: Assessing fault resilience in MPI stencil applications
+
+*Roberto Rocco, Elisabetta Boella, Daniele Gregori, Gianluca Palermo*
+
+**TL;DR** — Systematically evaluates the cost-benefit trade-off between full fault recovery and partial resilience strategies for MPI stencil computations under process failures.
+
+**Why notable** — Provides practitioners with a principled decision framework for resilience in HPC applications, showing when expensive full recovery is justified versus cheaper degraded-mode execution.
+
+---
+
+### A lightweight RDMA connection protocol based on post-hoc confirmation
+
+*Ke Wu 0003, Dezun Dong, Weixia Xu 0001*
+
+**TL;DR** — Designs an RDMA connection protocol that defers acknowledgment to post-operation confirmation, drastically reducing connection setup overhead for short-lived high-frequency transfers.
+
+**Why notable** — RDMA setup latency is a critical bottleneck in disaggregated memory and distributed storage systems; this protocol's approach generalizes to any latency-sensitive fabric.
+

site/content/cloud-edge/digests/JPDC-2026/index.md

@@ -0,0 +1,13 @@
+---
+title: JPDC 2026 Digest
+venue: JPDC
+year: 2026
+date: '2026-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/Middleware-2024/index.md

@@ -0,0 +1,147 @@
+---
+title: Middleware 2024 Digest
+venue: Middleware
+year: 2024
+date: '2024-12-02'
+tags:
+- distributed-systems
+- edge-computing
+- cloud
+paper_count: 11
+draft: false
+---
+
+11 papers selected.
+
+---
+
+### Chasing Lightspeed Consensus: Fast Wide-Area Byzantine Replication with Mercury
+
+*Christian Berger 0006, Lívio Rodrigues, Hans P. Reiser, Vinicius Vielmo Cogo *et al.**
+
+**TL;DR** — Mercury is a wide-area Byzantine fault-tolerant replication protocol that minimises latency by exploiting geographic locality and pipelining to approach the theoretical lightspeed bound.
+
+**Why notable** — Achieving near-lightspeed latency in Byzantine replication across wide-area networks has been a long-standing open challenge; Mercury's design demonstrates it is practically attainable. The result raises the bar for what production BFT middleware can deliver in geo-distributed deployments.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3700756)
+
+---
+
+### L3: Latency-aware Load Balancing in Multi-Cluster Service Mesh
+
+*Olivier Michaelis, Stefan Schmid 0001, Habib Mostafaei*
+
+**TL;DR** — L3 introduces a latency-aware load-balancing layer for multi-cluster service meshes that dynamically routes requests based on real-time latency measurements rather than static weights.
+
+**Why notable** — Service meshes are now the de-facto inter-service communication fabric in cloud-native stacks, yet most shipped load balancers remain latency-oblivious; L3 shows measurable tail-latency improvements in realistic multi-cluster topologies. Its design integrates cleanly with existing mesh control planes, giving operators a low-friction adoption path.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3654793)
+
+---
+
+### zkStream: a Framework for Trustworthy Stream Processing
+
+*Janwillem Swalens, Lode Hoste, Emad Heydari Beni, Lieven Trappeniers*
+
+**TL;DR** — zkStream applies zero-knowledge proofs to stream processing pipelines so that consumers can cryptographically verify the correctness of aggregated results without re-executing the pipeline.
+
+**Why notable** — Trustworthy stream processing has historically required either trusted execution environments or full result recomputation; zkStream shows that ZK proofs are now practical enough for continuous dataflow workloads. This has direct implications for regulatory-compliance and cross-organisation data sharing scenarios.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3700763)
+
+---
+
+### STRATA: Random Forests going Serverless
+
+*Dimitrios Tomaras, Sebastian Buschjäger, Vana Kalogeraki, Katharina Morik *et al.**
+
+**TL;DR** — STRATA decomposes random-forest inference into fine-grained serverless functions, exploiting embarrassing parallelism to cut inference latency while bounding cost.
+
+**Why notable** — Mapping classical ensemble models onto FaaS platforms exposes a new class of ML inference workloads for serverless runtimes, well beyond the simple stateless functions they were designed for. The cost-latency trade-off analysis provides a practical blueprint for teams already operating serverless infrastructure who want to serve ML models without dedicated GPU instances.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3654791)
+
+---
+
+### HORSE: Ultra-low latency workloads on FaaS platforms
+
+*Djob Mvondo, François Taïani, Yérom-David Bromberg*
+
+**TL;DR** — HORSE is a FaaS runtime extension that achieves sub-millisecond cold-start and execution latency for latency-critical functions by pre-warming micro-VMs and bypassing the standard invocation control plane.
+
+**Why notable** — The conventional wisdom that serverless is unsuitable for latency-critical workloads is directly challenged here; the authors achieve latencies competitive with always-on microservices. This opens the door to unifying latency-tolerant and latency-critical workloads under a single FaaS billing model.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3700784)
+
+---
+
+### In Serverless, OS Scheduler Choice Costs Money: A Hybrid Scheduling Approach for Cheaper FaaS
+
+*Yuxuan Zhao 0003, Weikang Weng, Rob van Nieuwpoort, Alexandru Uta*
+
+**TL;DR** — The paper quantifies how the Linux kernel scheduler directly inflates FaaS platform costs and proposes a hybrid scheduling policy that cuts CPU billing by significant margins without degrading function latency.
+
+**Why notable** — The finding that OS-level scheduling decisions have a measurable monetary impact on cloud provider bills is surprising and practically important for both FaaS platform operators and tenants. The proposed hybrid scheduler is deployable without changes to user functions or the FaaS API surface.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3700757)
+
+---
+
+### Ripple: Large-Scale Service and Configuration Management in the Cloud
+
+*Shuping Ji, Zhen Tang, Wei Wang 0049, Hui Li *et al.**
+
+**TL;DR** — Ripple is a scalable configuration-propagation system for cloud services that guarantees consistency and low-latency delivery of configuration updates across tens of thousands of service instances.
+
+**Why notable** — Configuration drift is a leading cause of production incidents in large-scale microservice deployments; Ripple demonstrates that consistent, fast propagation is achievable at cloud scale without sacrificing availability. The industry provenance of the work suggests it addresses real operational pain points at hyperscaler deployments.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3700777)
+
+---
+
+### FLEdge: Benchmarking Federated Learning Applications in Edge Computing Systems
+
+*Herbert Woisetschläger, Alexander Erben, Ruben Mayer, Shiqiang Wang 0001 *et al.**
+
+**TL;DR** — FLEdge provides a comprehensive benchmark suite for federated learning on edge hardware, covering realistic device heterogeneity, network variability, and energy constraints.
+
+**Why notable** — Reproducible evaluation of federated learning at the edge has been hindered by the absence of a standard benchmark; FLEdge fills this gap with a methodology grounded in real edge-device profiles. The benchmark is expected to become a reference point for comparing future edge FL middleware.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3700751)
+
+---
+
+### RoleML: a Role-Oriented Programming Model for Customizable Distributed Machine Learning on Edges
+
+*Yuesheng Tan, Lei Yang 0024, Wenhao Li, Yuda Wu*
+
+**TL;DR** — RoleML introduces a role-oriented abstraction that lets developers compose distributed ML training and inference topologies on heterogeneous edge nodes without coupling application logic to a specific communication or aggregation pattern.
+
+**Why notable** — Existing distributed ML frameworks force a tight coupling between the training algorithm and its communication topology, making it hard to adapt to the heterogeneous, dynamic connectivity of edge environments; RoleML's role abstraction decouples these concerns. The model shows how programming-model innovation at the middleware level can substantially reduce the engineering burden of deploying ML at the edge.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3700765)
+
+---
+
+### Dexter: A Performance-Cost Efficient Resource Allocation Manager for Serverless Data Analytics
+
+*Anna Maria Nestorov, Diego Marrón, Alberto Gutierrez-Torre, Chen Wang 0039 *et al.**
+
+**TL;DR** — Dexter automatically right-sizes serverless function resources for data-analytics jobs by learning cost and performance models online, reducing cloud spend while meeting latency SLOs.
+
+**Why notable** — Serverless data analytics workloads exhibit highly variable resource needs that defeat static provisioning; Dexter's online learning approach closes the feedback loop between observed performance and resource allocation in a way that is transparent to the user's code. The evaluation on real analytics pipelines shows double-digit cost reductions compared to vendor-default configurations.
+
+[→ Read paper](https://doi.org/10.1145/3652892.3700753)
+
+---
+
+### Serverful Functions: Leveraging Servers in Complex Serverless Workflows (industry track)
+
+*Germán T. Eizaguirre, Daniel Barcelona Pons, Aitor Arjona, Gil Vernik *et al.**
+
+**TL;DR** — Serverful Functions extends the serverless programming model with the ability to transparently route parts of a workflow to persistent server processes when stateful or long-running operations make pure FaaS impractical.
+
+**Why notable** — The serverless/serverful boundary is a persistent friction point for workflow authors dealing with state or warm-data locality; this industry paper demonstrates a production-ready hybrid that lets a single workflow span both worlds without application-level awareness. It signals a convergence trend that will shape the next generation of FaaS platforms.
+
+[→ Read paper](https://doi.org/10.1145/3700824.3701095)
+

site/content/cloud-edge/digests/Middleware-2025/index.md

@@ -0,0 +1,108 @@
+---
+title: Middleware 2025 Digest
+venue: Middleware
+year: 2025
+date: '2025-01-01'
+tags: []
+paper_count: 12
+draft: false
+---
+
+12 papers selected.
+
+---
+
+### Recipe: Hardware-Accelerated Replication Protocols: Rethinking Crash Fault Tolerance Protocols for Untrusted Cloud Environments
+
+*Dimitra Giantsidi, Emmanouil Giortamis, Julian Pritzi, Maurice Bailleu *et al.**
+
+**TL;DR** — Redesigns crash fault-tolerance protocols using hardware acceleration (TEEs/SmartNICs) to deliver replication with strong guarantees in untrusted cloud environments.
+
+---
+
+### Efficient Performance Guarantees for Function-as-a-Service with Cloud Allocators
+
+*Hai Duc Nguyen 0005, Andrew A. Chien*
+
+**TL;DR** — Introduces cloud-allocator abstractions that provide formal performance guarantees for serverless functions, addressing the unpredictability of shared FaaS infrastructure.
+
+---
+
+### Capybara: an Edge-Friendly Distributed Object Store for Diverse Serverless Functions
+
+*Xin Chen 0084, Manoj Prabhakar Paidiparthy, Chen Qian 0001, Liting Hu*
+
+**TL;DR** — Proposes a distributed object store purpose-built for edge serverless workloads, enabling diverse function runtimes to share state efficiently at the edge.
+
+---
+
+### EdgeConnector: Enabling Seamless and Efficient Cross-Cluster Device Access in Edge Environment
+
+*Yunna Cui, Liwei Shen, Bingkun Sun, Wente Lu *et al.**
+
+**TL;DR** — Presents a middleware layer that transparently bridges device access across Kubernetes clusters in heterogeneous edge deployments.
+
+---
+
+### FaaSImage: An Efficient Image Manager for FaaS
+
+*Abhisek Panda, Smruti R. Sarangi*
+
+**TL;DR** — Tackles cold-start latency in production FaaS platforms by redesigning container image management with fine-grained layer sharing and prefetching.
+
+---
+
+### Roadrunner: Accelerating Data Delivery to WebAssembly-Based Serverless Functions
+
+*Cynthia Marcelino, Thomas W. Pusztai, Stefan Nastic*
+
+**TL;DR** — Designs a high-throughput data-plane runtime that removes I/O bottlenecks for Wasm serverless functions through zero-copy data paths.
+
+---
+
+### Mocha: Scalable and Compliant Function Scheduling for Federated Serverless Computing
+
+*Yuqiu Zhang, Hans-Arno Jacobsen*
+
+**TL;DR** — Introduces a scheduler for federated serverless environments that satisfies data-residency and compliance constraints while maintaining high resource utilization.
+
+---
+
+### A Hybrid Runtime for Function-as-a-Service at the Edge
+
+*Adam Hall, Umakishore Ramachandran*
+
+**TL;DR** — Combines container and unikernel execution models in a single FaaS runtime to balance isolation, startup latency, and resource efficiency at edge nodes.
+
+---
+
+### Tiaccoon: Unified Access Control with Multiple Transports in Container Networks
+
+*Hiroya Onoe, Daisuke Kotani, Yasuo Okabe*
+
+**TL;DR** — Provides a service-mesh-style unified access-control plane that works across heterogeneous transport protocols within container network environments.
+
+---
+
+### MiAR-BFT: Efficient Leaderless Consensus Based on Multi-instance Asynchronous Running for Blockchain
+
+*Zhenyu Zhang, Xing Tong, Zhao Zhang 0009, Cheqing Jin*
+
+**TL;DR** — Proposes a leaderless BFT consensus protocol that runs multiple instances concurrently to improve throughput and reduce latency in blockchain middleware.
+
+---
+
+### ER-π: Exhaustive Interleaving Replay for Testing Replicated Data Library Integration
+
+*Provakar Mondal, Eli Tilevich*
+
+**TL;DR** — Systematically explores all message interleavings when testing replicated data libraries, surfacing integration bugs that random testing misses in distributed coordination code.
+
+---
+
+### Adjusted Objects: An Efficient and Principled Approach to Scalable Programming
+
+*Boubacar Kane, Pierre Sutra*
+
+**TL;DR** — Introduces adjusted objects as a programming abstraction that reconciles strong consistency with scalability, offering a practical alternative to CRDTs for distributed middleware.
+

site/content/cloud-edge/digests/Middleware-2026/index.md

@@ -0,0 +1,13 @@
+---
+title: Middleware 2026 Digest
+venue: Middleware
+year: 2026
+date: '2026-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/MobiSys-2024/index.md

@@ -0,0 +1,116 @@
+---
+title: MobiSys 2024 Digest
+venue: MobiSys
+year: 2024
+date: '2024-01-01'
+tags: []
+paper_count: 13
+draft: false
+---
+
+13 papers selected.
+
+---
+
+### WAIS: Leveraging WiFi for Resource-Efficient SLAM
+
+*Aditya Arun 0002, William Hunter, Roshan Sai Ayyalasomayajula, Dinesh Bharadia*
+
+**TL;DR** — Demonstrates that commodity WiFi signals can replace LiDAR for simultaneous localization and mapping, dramatically cutting the resource cost of robot/AR navigation.
+
+---
+
+### UWB-Fi: Pushing Wi-Fi towards Ultra-wideband for Fine-Granularity Sensing
+
+*Xin Li 0070, Hongbo Wang, Zhe Chen 0015, Zhiping Jiang *et al.**
+
+**TL;DR** — Extends standard Wi-Fi to UWB-class sensing resolution without hardware changes, enabling centimeter-level gesture and motion detection on existing infrastructure.
+
+---
+
+### Radarize: Enhancing Radar SLAM with Generalizable Doppler-Based Odometry
+
+*Emerson Sie, Xinyu Wu, Heyu Guo, Deepak Vasisht*
+
+**TL;DR** — Introduces a Doppler-derived odometry method that generalizes radar-based SLAM across environments and radar hardware without per-deployment retraining.
+
+---
+
+### ChirpTransformer: Versatile LoRa Encoding for Low-power Wide-area IoT
+
+*Chenning Li, Yidong Ren, Shuai Tong, Shakhrul Iman Siam *et al.**
+
+**TL;DR** — Redesigns LoRa chirp encoding with a transformer-based scheme that simultaneously improves throughput, range, and coexistence for large-scale IoT deployments.
+
+---
+
+### Willow: Practical WiFi Backscatter Localization with Parallel Tags
+
+*Jinyan Jiang, Jiliang Wang, Yijie Chen, Shuai Tong *et al.**
+
+**TL;DR** — Enables concurrent localization of multiple passive backscatter tags over commodity WiFi, making large-scale battery-free asset tracking practical.
+
+---
+
+### Pantheon: Preemptible Multi-DNN Inference on Mobile Edge GPUs
+
+*Lixiang Han, Zimu Zhou, Zhenjiang Li*
+
+**TL;DR** — Provides a preemptible scheduling runtime for concurrent DNN workloads on edge GPUs, achieving low-latency inference without sacrificing throughput under mixed real-time demands.
+
+---
+
+### ARISE: High-Capacity AR Offloading Inference Serving via Proactive Scheduling
+
+*Z. Jonny Kong, Qiang Xu 0006, Y. Charlie Hu*
+
+**TL;DR** — Proactively schedules AR inference offloading by predicting gaze and scene dynamics, significantly increasing server capacity while meeting strict latency budgets.
+
+---
+
+### CACTUS: Dynamically Switchable Context-aware micro-Classifiers for Efficient IoT Inference
+
+*Mohammad Mehdi Rastikerdar, Jin Huang, Shiwei Fang, Hui Guan 0001 *et al.**
+
+**TL;DR** — Deploys a family of tiny context-aware classifiers on microcontrollers that switch at runtime to match workload context, cutting energy by orders of magnitude versus monolithic models.
+
+---
+
+### Empowering In-Browser Deep Learning Inference on Edge Through Just-In-Time Kernel Optimization
+
+*Fucheng Jia, Shiqi Jiang 0002, Ting Cao 0003, Wei Cui *et al.**
+
+**TL;DR** — Uses JIT kernel specialization to close the performance gap between browser-based and native DNN inference on edge devices, enabling high-throughput on-device AI in web apps.
+
+---
+
+### FedConv: A Learning-on-Model Paradigm for Heterogeneous Federated Clients
+
+*Leming Shen, Qiang Yang 0018, Kaiyan Cui, Yuanqing Zheng *et al.**
+
+**TL;DR** — Proposes learning directly over model parameters rather than data, allowing federated learning to work across radically heterogeneous IoT devices without sharing raw data or requiring uniform architectures.
+
+---
+
+### SoilCares: Towards Low-cost Soil Macronutrients and Moisture Monitoring Using RF-VNIR Sensing
+
+*Juexing Wang, Yuda Feng, Gouree Kumbhar, Guangjing Wang 0001 *et al.**
+
+**TL;DR** — Combines RF and near-infrared sensing in a low-cost handheld device to measure soil nutrients and moisture, demonstrating real agricultural field deployments.
+
+---
+
+### MobiAir: Unleashing Sensor Mobility for City-scale and Fine-grained Air-Quality Monitoring with AirBERT
+
+*Yuxuan Liu 0010, Haoyang Wang 0012, Fanhang Man, Jingao Xu *et al.**
+
+**TL;DR** — Leverages mobile sensors on vehicles and pedestrians with a BERT-style spatio-temporal model to achieve city-scale, fine-grained air quality maps at a fraction of the cost of static sensor networks.
+
+---
+
+### Joey: Supporting Kangaroo Mother Care with Computational Fabrics
+
+*Qijia Shao, Jiting Liu, Emily Bejerano, Ho-Man Colman Leung *et al.**
+
+**TL;DR** — Embeds soft physiological sensors directly into a wearable fabric wrap to monitor premature infants during skin-to-skin care, demonstrating a compelling real-world clinical deployment.
+

site/content/cloud-edge/digests/MobiSys-2025/index.md

@@ -0,0 +1,159 @@
+---
+title: MobiSys 2025 Digest
+venue: MobiSys
+year: 2025
+date: '2025-06-23'
+tags:
+- mobile-computing
+- edge-computing
+- networking
+paper_count: 12
+draft: false
+---
+
+12 papers selected.
+
+---
+
+### Hopter: a Safe, Robust, and Responsive Embedded Operating System
+
+*Zhiyao Ma, Guojun Chen, Zhuo Chen 0011, Lin Zhong 0001*
+
+**TL;DR** — Hopter is a new embedded OS that enforces memory safety and real-time responsiveness through a Rust-based task model with cooperative and preemptive scheduling co-designed from the ground up.
+
+**Why notable** — Building a ground-up safe embedded OS is a long-standing challenge; Hopter addresses it without sacrificing the determinism that IoT and robotics workloads demand, offering a credible alternative to unsafe C-based RTOSes.
+
+[→ Read paper](https://doi.org/10.1145/3711875.3729149)
+
+---
+
+### WhisperFlow: speech foundation models in real time
+
+*Rongxiang Wang, Zhiming Xu 0001, Felix Xiaozhu Lin*
+
+**TL;DR** — WhisperFlow pipelines and partially overlaps Whisper's encode-decode stages so that large speech foundation models can transcribe audio with latency low enough for interactive mobile use.
+
+**Why notable** — Running large encoder-decoder speech models in real time on mobile hardware was previously impractical; the paper shows that careful pipeline scheduling—not quantization alone—can close this gap, with implications for on-device voice assistants.
+
+[→ Read paper](https://doi.org/10.1145/3711875.3729151)
+
+---
+
+### ARIA: Optimizing Vision Foundation Model Inference on Heterogeneous Mobile Processors for Augmented Reality
+
+*Chanyoung Jung, Jeho Lee, Gunjoong Kim, Jiwon Kim *et al.**
+
+**TL;DR** — ARIA partitions and schedules vision foundation model layers across CPU, GPU, and NPU on a mobile SoC to meet the strict latency budget of augmented-reality pipelines.
+
+**Why notable** — Foundation models are typically too large for AR frame rates; ARIA's heterogeneous mapping strategy achieves real-time throughput without dedicated server offload, making high-quality AR semantics viable on commodity handsets.
+
+[→ Read paper](https://doi.org/10.1145/3711875.3729161)
+
+---
+
+### You Only Render Once: Enhancing Energy and Computation Efficiency of Mobile Virtual Reality
+
+*Xingyu Chen, Xinmin Fang, Shuting Zhang, Xinyu Zhang 0003 *et al.**
+
+**TL;DR** — YORO eliminates redundant per-eye rendering in mobile VR by synthesizing one eye's view from the other using a lightweight neural warp, cutting GPU work nearly in half.
+
+**Why notable** — Stereo rendering is the dominant energy cost in standalone VR headsets; halving it via a neural single-render approach is a surprising result that could significantly extend battery life on devices like Quest.
+
+[→ Read paper](https://doi.org/10.1145/3711875.3729133)
+
+---
+
+### AutoDroid-V2: Boosting SLM-based GUI Agents via Code Generation
+
+*Hao Wen 0004, Shizuo Tian, Borislav Pavlov, Wenjie Du 0004 *et al.**
+
+**TL;DR** — AutoDroid-V2 improves on-device GUI automation agents by having a small language model generate executable action code rather than selecting from a fixed action vocabulary, dramatically improving task success rates.
+
+**Why notable** — Shifting from action classification to code generation is a paradigm change for mobile agents; the paper demonstrates that even small, phone-resident SLMs can outperform larger cloud models on standard Android benchmarks when given the right output format.
+
+[→ Read paper](https://doi.org/10.1145/3711875.3729134)
+
+---
+
+### EdgeLoRA: An Efficient Multi-Tenant LLM Serving System on Edge Devices
+
+*Zheyu Shen, Yexiao He, Ziyao Wang, Yuning Zhang *et al.**
+
+**TL;DR** — EdgeLoRA multiplexes many LoRA-adapted LLM variants on a single edge GPU by sharing the frozen base model weights and swapping only the low-rank adapters, enabling multi-tenant LLM inference at the edge.
+
+**Why notable** — Multi-tenant serving of personalized LLMs on a single edge node is an open systems problem; EdgeLoRA's adapter-swap architecture achieves near-dedicated throughput per tenant while keeping memory footprint proportional to the number of adapters rather than full model copies.
+
+[→ Read paper](https://doi.org/10.1145/3711875.3729141)
+
+---
+
+### Never Start from Scratch: Expediting On-Device LLM Personalization via Explainable Model Selection
+
+*Haoming Wang 0002, Boyuan Yang 0001, Xiangyu Yin 0002, Wei Gao 0006*
+
+**TL;DR** — Rather than fine-tuning from a generic base, this system selects the best pre-existing task-specific model checkpoint as the personalization starting point, guided by an interpretable feature-matching score.
+
+**Why notable** — The finding that checkpoint selection dominates fine-tuning cost savings—and that an explainable selector can match exhaustive search—challenges the assumption that on-device personalization must always begin from a single canonical base model.
+
+[→ Read paper](https://doi.org/10.1145/3711875.3729132)
+
+---
+
+### Non-Line-of-Sight 3D Object Reconstruction via mmWave Surface Normal Estimation
+
+*Laura Dodds, Tara Boroushaki, Kaichen Zhou, Fadel Adib*
+
+**TL;DR** — By estimating surface normals from mmWave reflections, this system reconstructs the 3D shape of objects hidden around corners without requiring a line-of-sight path.
+
+**Why notable** — NLOS 3D reconstruction with commodity mmWave hardware is a significant sensing advance; using surface normals rather than time-of-flight alone yields object reconstructions detailed enough to identify object categories, with clear implications for autonomous driving and search-and-rescue.
+
+[→ Read paper](https://doi.org/10.1145/3711875.3729138)
+
+---
+
+### Toward Spoofing-Resilient and Communication-Integrated MmWave Radar Sensing
+
+*Kun Qian 0004, Parth Pathak 0001*
+
+**TL;DR** — This work integrates communication waveforms into mmWave radar so that sensing and data transmission share the same spectrum, while a spoofing-resilience mechanism prevents adversarial injection of false radar echoes.
+
+**Why notable** — Combining ISAC (integrated sensing and communications) with active spoofing defense in a single mmWave system addresses two open problems at once; the result is particularly relevant as mmWave bands are slated for both 5G and automotive radar use.
+
+[→ Read paper](https://doi.org/10.1145/3711875.3729155)
+
+---
+
+### Are LoRa Logical Channels Really Orthogonal? Practically Orthogonalizing Massive Logical Channels
+
+*Shiming Yu, Ziyue Zhang, Xianjin Xia, Yuanqing Zheng *et al.**
+
+**TL;DR** — The paper shows that LoRa's supposedly orthogonal spreading-factor channels have measurable inter-channel interference at scale, then proposes a software-only scheduler that restores near-perfect orthogonality for dense deployments.
+
+**Why notable** — The result that LoRa orthogonality breaks down in realistic dense networks—and that a pure software fix suffices—is a surprising finding that will directly affect how city-scale IoT networks are planned and managed.
+
+[→ Read paper](https://doi.org/10.1145/3711875.3729125)
+
+---
+
+### Towards End-to-End Latency Guarantee in MEC Live Video Analytics with App-RAN Mutual Awareness
+
+*Juheon Yi, Goodsol Lee, Minkyung Jeong, Seokgyeong Shin *et al.**
+
+**TL;DR** — By exposing RAN scheduling state to the MEC video analytics application—and letting the app's feedback influence RAN scheduling—this system achieves end-to-end latency guarantees that neither layer can provide alone.
+
+**Why notable** — Cross-layer co-design between the RAN and MEC application is rarely demonstrated in a working system; the paper shows that even coarse-grained mutual awareness cuts tail latency by over 50% compared to independent operation.
+
+[→ Read paper](https://doi.org/10.1145/3711875.3729139)
+
+---
+
+### Unraveling the Missing Link in Low-power Communication: An Autodyning Receiver Architecture that Achieves a Long Range
+
+*Pramuka Medaranga Sooriya Patabandige, Rajashekar Reddy Chinthalapani, Wenqing Yan, Prabal Dutta *et al.**
+
+**TL;DR** — An autodyning receiver design reuses the transmit oscillator for self-mixing, eliminating a separate LO and achieving orders-of-magnitude better sensitivity than prior backscatter receivers without added hardware cost.
+
+**Why notable** — Long-range backscatter has been a persistent gap between battery-free IoT and practical deployment; this architecture achieves kilometer-scale range on microwatts of harvested energy, a result that could unlock new classes of batteryless sensors.
+
+[→ Read paper](https://doi.org/10.1145/3711875.3729164)
+

site/content/cloud-edge/digests/MobiSys-2026/index.md

@@ -0,0 +1,13 @@
+---
+title: MobiSys 2026 Digest
+venue: MobiSys
+year: 2026
+date: '2026-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/NSDI-2024/index.md

@@ -0,0 +1,116 @@
+---
+title: NSDI 2024 Digest
+venue: NSDI
+year: 2024
+date: '2024-01-01'
+tags: []
+paper_count: 13
+draft: false
+---
+
+13 papers selected.
+
+---
+
+### MegaScale: Scaling Large Language Model Training to More Than 10, 000 GPUs
+
+*Ziheng Jiang, Haibin Lin, Yinmin Zhong, Qi Huang *et al.**
+
+**TL;DR** — ByteDance's full production account of training LLMs at 10,000+ GPUs, with novel co-design of the network stack, fault tolerance, and collective communication to sustain near-linear scaling.
+
+---
+
+### Harmony: A Congestion-free Datacenter Architecture
+
+*Saksham Agarwal, Qizhe Cai, Rachit Agarwal 0001, David B. Shmoys *et al.**
+
+**TL;DR** — Proposes rethinking datacenter fabrics to eliminate congestion by construction rather than managing it reactively, achieving line-rate throughput without per-packet feedback from Cornell and Google.
+
+---
+
+### DINT: Fast In-Kernel Distributed Transactions with eBPF
+
+*Yang Zhou 0008, Xingyu Xiang, Matthew Kiley, Sowmya Dharanipragada *et al.**
+
+**TL;DR** — Demonstrates that eBPF programs executing entirely inside the kernel can enforce linearizable, ACID-compliant distributed transactions at dramatically lower latency than user-space approaches.
+
+---
+
+### Making Kernel Bypass Practical for the Cloud with Junction
+
+*Joshua Fried, Gohar Irfan Chaudhry, Enrique Saurez, Esha Choukse *et al.**
+
+**TL;DR** — Junction (MIT + Microsoft) is the first system to bring full kernel-bypass networking to multi-tenant cloud VMs without requiring application modifications or sacrificing isolation.
+
+---
+
+### SIEVE is Simpler than LRU: an Efficient Turn-Key Eviction Algorithm for Web Caches
+
+*Yazhuo Zhang, Juncheng Yang, Yao Yue, Ymir Vigfusson *et al.**
+
+**TL;DR** — Surprising finding that a single-queue eviction policy requiring almost no state changes outperforms LRU and all modern approximations on production web-cache workloads.
+
+---
+
+### A large-scale deployment of DCTCP
+
+*Abhishek Dhamija, Balasubramanian Madhavan, Hechao Li, Jie Meng *et al.**
+
+**TL;DR** — A rare, candid production report from Meta on deploying DCTCP at hyperscale, surfacing unexpected interactions with heterogeneous hardware, cross-traffic, and operational constraints.
+
+---
+
+### Brain-on-Switch: Towards Advanced Intelligent Network Data Plane via NN-Driven Traffic Analysis at Line-Speed
+
+*Jinzhu Yan, Haotian Xu, Zhuotao Liu, Qi Li 0002 *et al.**
+
+**TL;DR** — Executes neural-network inference for traffic classification directly in the programmable switch data plane at line rate, eliminating the round-trip to a CPU-based classifier.
+
+---
+
+### Horus: Granular In-Network Task Scheduler for Cloud Datacenters
+
+*Parham Yassini, Khaled Diab 0001, Saeed Mahloujifar, Mohamed Hefeeda*
+
+**TL;DR** — Offloads microsecond-granularity task scheduling decisions into programmable switches, reducing load-balancing latency by orders of magnitude compared to software schedulers.
+
+---
+
+### CAPA: An Architecture For Operating Cluster Networks With High Availability
+
+*Bingzhe Liu, Colin Scott, Mukarram Tariq, Andrew D. Ferguson *et al.**
+
+**TL;DR** — Google's production architecture for maintaining five-nines availability in Jupiter-scale cluster networks, detailing how control-plane redundancy and fast failover are achieved in practice.
+
+---
+
+### Revisiting Congestion Control for Lossless Ethernet
+
+*Yiran Zhang, Qingkai Meng 0001, Chaolei Hu, Fengyuan Ren*
+
+**TL;DR** — Identifies fundamental flaws in PFC-based lossless Ethernet that cause cascading head-of-line blocking and proposes a redesigned congestion control that avoids them.
+
+---
+
+### Sirius: Composing Network Function Chains into P4-Capable Edge Gateways
+
+*Jiaqi Gao, Jiamin Cao, Yifan Li, Mengqi Liu 0001 *et al.**
+
+**TL;DR** — Alibaba's production system for composing arbitrary NF chains into P4-programmed edge gateways, replacing a fleet of dedicated middleboxes and cutting per-packet processing cost significantly.
+
+---
+
+### CASSINI: Network-Aware Job Scheduling in Machine Learning Clusters
+
+*Sudarsanan Rajasekaran, Manya Ghobadi, Aditya Akella*
+
+**TL;DR** — Shows that ignoring network topology when scheduling ML training jobs causes severe collective-communication contention, and that topology-aware co-scheduling yields substantial throughput gains.
+
+---
+
+### Cloudcast: High-Throughput, Cost-Aware Overlay Multicast in the Cloud
+
+*Sarah Wooders, Shu Liu, Paras Jain 0001, Xiangxi Mo *et al.**
+
+**TL;DR** — Berkeley/Penn system that builds overlay multicast trees across cloud regions optimized for egress cost, enabling high-throughput data dissemination at a fraction of unicast cloud egress fees.
+

site/content/cloud-edge/digests/NSDI-2025/index.md

@@ -0,0 +1,177 @@
+---
+title: NSDI 2025 Digest
+venue: NSDI
+year: 2025
+date: '2025-04-28'
+tags:
+- networking
+- distributed-systems
+- cloud
+- programmable-data-planes
+- network-verification
+- datacenter
+- transport
+- ml-systems
+- 5g
+paper_count: 13
+draft: false
+---
+
+13 papers selected.
+
+---
+
+### PRED: Performance-oriented Random Early Detection for Consistently Stable Performance in Datacenters
+
+*Xinle Du, Tong Li 0014, Guangmeng Zhou, Zhuotao Liu *et al.**
+
+**TL;DR** — PRED redesigns AQM by making drop probability a direct function of per-flow performance targets rather than queue length, eliminating the instability of classic RED in modern datacenter workloads.
+
+**Why notable** — RED has been a cornerstone of congestion control for decades; PRED's performance-centric reformulation challenges a long-held design axiom and demonstrates significantly lower tail latency at scale. It opens the door to intent-driven AQM as a first-class primitive in datacenter switches.
+
+[→ Read paper](https://www.usenix.org/conference/nsdi25/presentation/du)
+
+---
+
+### Rajomon: Decentralized and Coordinated Overload Control for Latency-Sensitive Microservices
+
+*Jiali Xing, Akis Giannoukos, Paul Loh, Shuyue Wang *et al.**
+
+**TL;DR** — Rajomon introduces a token-based, decentralized overload control mechanism that coordinates admission across microservice call graphs without a central bottleneck.
+
+**Why notable** — Microservice overload propagation is a persistent pain point in production clouds; Rajomon's approach of spreading load-shedding decisions across the call graph while retaining global coherence is a practical and principled contribution. The system is evaluated on realistic cloud benchmarks and shows clear SLO improvement over prior centralized and uncoordinated schemes.
+
+[→ Read paper](https://www.usenix.org/conference/nsdi25/presentation/xing)
+
+---
+
+### Unlocking ECMP Programmability for Precise Traffic Control
+
+*Yadong Liu, Yunming Xiao, Xuan Zhang, Weizhen Dang *et al.**
+
+**TL;DR** — This work exposes fine-grained ECMP programming interfaces that allow operators to steer individual flows through specific paths in multipath datacenter fabrics with near-zero overhead.
+
+**Why notable** — ECMP's coarse hashing has been a limiting factor in datacenter traffic engineering for years; this paper shows that commodity switch primitives can be composed to achieve precise per-flow placement, delivering measurable improvements in load balance without topology changes.
+
+[→ Read paper](https://www.usenix.org/conference/nsdi25/presentation/liu-yadong)
+
+---
+
+### eTran: Extensible Kernel Transport with eBPF
+
+*Zhongjie Chen, Qingkai Meng 0001, ChonLam Lao, Yifan Liu *et al.**
+
+**TL;DR** — eTran uses eBPF to let applications plug in custom transport logic—including RDMA-like zero-copy paths—directly into the Linux kernel data path without modifying kernel source.
+
+**Why notable** — The ability to safely extend kernel networking with eBPF has been widely anticipated; eTran demonstrates that full transport protocols (not just classifiers) can be realised this way, achieving performance competitive with kernel-bypass while retaining OS isolation and deployability.
+
+[→ Read paper](https://www.usenix.org/conference/nsdi25/presentation/chen-zhongjie)
+
+---
+
+### White-Boxing RDMA with Packet-Granular Software Control
+
+*Chenxingyu Zhao, Jaehong Min, Ming Liu 0027, Arvind Krishnamurthy*
+
+**TL;DR** — This paper decomposes RDMA semantics and re-implements them in software at packet granularity, exposing hooks that allow transport policy (retransmission, congestion, multipath) to be modified without hardware changes.
+
+**Why notable** — RDMA's black-box nature has long frustrated datacenter operators trying to deploy custom congestion control or network telemetry; white-boxing RDMA at packet granularity is a principled answer that simultaneously improves debuggability and extensibility, with demonstrated line-rate performance.
+
+[→ Read paper](https://www.usenix.org/conference/nsdi25/presentation/zhao-chenxingyu)
+
+---
+
+### NDD: A Decision Diagram for Network Verification
+
+*Zechun Li, Peng Zhang 0011, Yichi Zhang, Hongkun Yang*
+
+**TL;DR** — NDD is a new symbolic data structure that compactly represents the forwarding behavior of large networks, enabling network verification queries orders of magnitude faster than BDD-based predecessors.
+
+**Why notable** — Network verification tools like Batfish and ARC rely on set representations whose size can explode on real networks; NDD's topology-aware decomposition dramatically reduces verification time for common queries (reachability, loop detection) and is likely to be adopted as a backend in production verification pipelines.
+
+[→ Read paper](https://www.usenix.org/conference/nsdi25/presentation/li-zechun)
+
+---
+
+### VEP: A Two-stage Verification Toolchain for Full eBPF Programmability
+
+*Xiwei Wu, Yueyang Feng, Tianyi Huang, Xiaoyang Lu *et al.**
+
+**TL;DR** — VEP combines abstract interpretation with deductive verification to prove safety properties of eBPF programs that the Linux kernel verifier rejects, enabling a much wider class of programs to run safely in the kernel.
+
+**Why notable** — The Linux eBPF verifier's conservatism blocks many useful programs; VEP's two-stage approach (lightweight in-kernel check plus offline proof) expands the programmability frontier without weakening safety guarantees, directly affecting every operator who writes eBPF for networking or observability.
+
+[→ Read paper](https://www.usenix.org/conference/nsdi25/presentation/wu-xiwei)
+
+---
+
+### MTP: Transport for In-Network Computing
+
+*Tao Ji, Rohan Vardekar, Balajee Vamanan, Brent E. Stephens *et al.**
+
+**TL;DR** — MTP is a transport protocol co-designed with programmable switches that allows in-network compute operations (aggregation, filtering) to be expressed as first-class transport primitives with reliability and flow-control guarantees.
+
+**Why notable** — Existing transports treat the network as a dumb pipe and retrofit in-network compute as an afterthought; MTP shows that rethinking transport abstractions around programmable hardware can yield substantial throughput gains for distributed ML and key-value workloads.
+
+[→ Read paper](https://www.usenix.org/conference/nsdi25/presentation/ji)
+
+---
+
+### State-Compute Replication: Parallelizing High-Speed Stateful Packet Processing
+
+*Qiongwen Xu, Sebastiano Miano, Xiangyu Gao, Tao Wang 0088 *et al.**
+
+**TL;DR** — This paper introduces a replication model for stateful packet processing that partitions state across multiple pipeline replicas and reconciles updates at line rate, breaking the single-pipeline bottleneck of P4 programs.
+
+**Why notable** — Stateful P4 programs that require per-flow counters or heavy-hitter detection are bottlenecked by single-instance state; the state-compute replication model is a general technique applicable across telemetry, load balancing, and security use cases, with a prototype running at 100 Gbps.
+
+[→ Read paper](https://www.usenix.org/conference/nsdi25/presentation/xu-qiongwen)
+
+---
+
+### Efficient Direct-Connect Topologies for Collective Communications
+
+*Liangyu Zhao, Siddharth Pal, Tapan Chugh, Weiyang Wang *et al.**
+
+**TL;DR** — This paper derives a family of direct-connect network topologies mathematically optimized for the all-reduce and all-to-all collectives used in large-scale ML training, achieving better bandwidth and lower diameter than fat-tree alternatives at the same port count.
+
+**Why notable** — As AI training clusters scale to thousands of GPUs, interconnect topology becomes a first-order performance determinant; the paper's analytical framework for topology synthesis fills a long-standing gap between graph theory and practical cluster networking, and the proposed topologies outperform fat-trees on real collective benchmarks.
+
+[→ Read paper](https://www.usenix.org/conference/nsdi25/presentation/zhao-liangyu)
+
+---
+
+### SimAI: Unifying Architecture Design and Performance Tuning for Large-Scale Large Language Model Training with Scalability and Precision
+
+*Xizheng Wang, Qingxu Li, Yichi Xu, Gang Lu *et al.**
+
+**TL;DR** — SimAI is a high-fidelity simulator that jointly models compute, network, and storage interactions in LLM training clusters, enabling architects to evaluate topology and parallelism strategy choices without running full cluster experiments.
+
+**Why notable** — Designing training infrastructure for frontier LLMs is prohibitively expensive to explore empirically; SimAI's validated accuracy against production Alibaba clusters makes it a practical tool for the community and provides rare quantitative insight into how network architecture choices affect end-to-end training throughput.
+
+[→ Read paper](https://www.usenix.org/conference/nsdi25/presentation/wang-xizheng-simai)
+
+---
+
+### Minder: Faulty Machine Detection for Large-scale Distributed Model Training
+
+*Yangtao Deng, Xiang Shi, Zhuo Jiang, Xingjian Zhang 0009 *et al.**
+
+**TL;DR** — Minder continuously monitors collective-communication timing patterns during LLM training to pinpoint faulty nodes—including subtle slow or flapping hardware—without requiring dedicated diagnostic jobs.
+
+**Why notable** — GPU cluster faults that cause training slowdowns rather than outright crashes are notoriously hard to attribute; Minder's passive monitoring approach catches a wide class of hardware anomalies (including network stragglers) with sub-minute detection latency, and its deployment at scale in Alibaba's training infrastructure gives the results strong operational credibility.
+
+[→ Read paper](https://www.usenix.org/conference/nsdi25/presentation/deng)
+
+---
+
+### Efficient Multi-WAN Transport for 5G with OTTER
+
+*Mary Hogan, Gerry Wan, Yiming Qiu, Sharad Agarwal *et al.**
+
+**TL;DR** — OTTER is a multi-path transport system for 5G user-plane traffic that dynamically bonds heterogeneous WAN links (e.g., terrestrial + satellite) while hiding link asymmetry and jitter from applications.
+
+**Why notable** — 5G deployments increasingly rely on diverse backhaul paths with wildly different characteristics; OTTER's scheduler, validated on a Microsoft production 5G deployment, demonstrates that significant throughput and reliability gains are achievable through principled multi-WAN design, informing both operator practice and future transport standards.
+
+[→ Read paper](https://www.usenix.org/conference/nsdi25/presentation/hogan)
+

site/content/cloud-edge/digests/NSDI-2027/index.md

@@ -0,0 +1,13 @@
+---
+title: NSDI 2027 Digest
+venue: NSDI
+year: 2027
+date: '2027-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/OSDI-2024/index.md

@@ -0,0 +1,150 @@
+---
+title: OSDI 2024 Digest
+venue: OSDI
+year: 2024
+date: '2024-07-10'
+tags:
+- llm-serving
+- distributed-systems
+- verification
+- memory
+- networking
+- storage
+draft: false
+paper_count: 11
+---
+
+11 papers selected.
+
+---
+
+### DistServe: Disaggregating Prefill and Decoding for Goodput-optimized Large Language Model Serving
+
+*Yinmin Zhong, Shengyu Liu, Junda Chen, Jianbo Hu *et al.**
+
+**TL;DR** — Separates the compute-heavy prefill phase from the memory-bound decoding phase onto different GPU pools, eliminating head-of-line blocking and significantly improving LLM serving throughput.
+
+**Why notable** — Became one of the most influential LLM systems papers of 2024; the prefill–decode disaggregation insight is now widely adopted in production inference stacks (vLLM, SGLang, etc.).
+
+[→ Read paper](https://www.usenix.org/conference/osdi24/presentation/zhong-yinmin)
+
+---
+
+### Fairness in Serving Large Language Models
+
+*Ying Sheng 0007, Shiyi Cao, Dacheng Li, Banghua Zhu *et al.**
+
+**TL;DR** — Introduces VTC, a token-count-weighted fair scheduling policy that prevents long-prompt users from monopolising GPU capacity in multi-tenant LLM services.
+
+**Why notable** — First paper to formally study multi-tenant fairness in LLM serving; directly influenced subsequent work on SLA-aware serving and resource allocation in shared inference clusters.
+
+[→ Read paper](https://www.usenix.org/conference/osdi24/presentation/sheng)
+
+---
+
+### Taming Throughput-Latency Tradeoff in LLM Inference with Sarathi-Serve
+
+*Amey Agrawal, Nitin Kedia, Ashish Panwar, Jayashree Mohan *et al.**
+
+**TL;DR** — Introduces chunked prefill and stall-free scheduling to decouple throughput and latency goals, letting the same serving system meet both SLOs simultaneously.
+
+**Why notable** — Elegant framing of the throughput–latency tension; chunked prefill became a standard technique in open-source inference engines within months of publication.
+
+[→ Read paper](https://www.usenix.org/conference/osdi24/presentation/agrawal)
+
+---
+
+### Llumnix: Dynamic Scheduling for Large Language Model Serving
+
+*Biao Sun 0002, Ziming Huang, Hanyu Zhao, Wencong Xiao *et al.**
+
+**TL;DR** — Treats in-flight LLM requests as migratable units, enabling load balancing and SLO recovery by live-migrating KV-cache state across GPU instances.
+
+**Why notable** — Request migration for LLM serving was considered impractical due to KV-cache size; this paper shows it is feasible and impactful, opening a new design dimension for inference schedulers.
+
+[→ Read paper](https://www.usenix.org/conference/osdi24/presentation/sun-biao)
+
+---
+
+### MAST: Global Scheduling of ML Training across Geo-Distributed Datacenters at Hyperscale
+
+*Arnab Choudhury, Yang Wang 0009, Tuomas Pelkonen, Kutta Srinivasan *et al.**
+
+**TL;DR** — Describes Google's production system for scheduling ML training jobs across geographically distributed datacenters, balancing GPU utilisation, job deadlines, and cross-datacenter bandwidth costs.
+
+**Why notable** — Rare large-scale production paper on global ML scheduling; the insights on heterogeneous cluster management and placement constraints are directly useful for anyone operating multi-site GPU infrastructure.
+
+[→ Read paper](https://www.usenix.org/conference/osdi24/presentation/choudhury)
+
+---
+
+### SquirrelFS: using the Rust compiler to check file-system crash consistency
+
+*Hayley LeBlanc, Nathan Taylor, James Bornholt, Vijay Chidambaram*
+
+**TL;DR** — Encodes crash-consistency invariants in Rust's type system so that a file system that compiles is guaranteed not to leave the storage in an inconsistent state after a crash.
+
+**Why notable** — A clean demonstration that language-level type checking can replace runtime or proof-assistant-based verification for an important systems property; the approach is general and practically viable.
+
+[→ Read paper](https://www.usenix.org/conference/osdi24/presentation/leblanc)
+
+---
+
+### Anvil: Verifying Liveness of Cluster Management Controllers
+
+*Xudong Sun 0013, Wenjie Ma, Jiawei Tyler Gu, Zicheng Ma *et al.**
+
+**TL;DR** — Presents the first framework for mechanically verifying liveness (eventual progress) of Kubernetes-style reconciliation controllers, with proofs for real controllers including ZooKeeper and RabbitMQ operators.
+
+**Why notable** — Liveness proofs for real-world cloud controllers were previously out of reach; Anvil's methodology closes a critical gap in the formal verification of cloud infrastructure.
+
+[→ Read paper](https://www.usenix.org/conference/osdi24/presentation/sun-xudong)
+
+---
+
+### DRust: Language-Guided Distributed Shared Memory with Fine Granularity, Full Transparency, and Ultra Efficiency
+
+*Haoran Ma, Yifan Qiao 0002, Shi Liu, Shan Yu *et al.**
+
+**TL;DR** — Exploits Rust's ownership model to implement distributed shared memory at cache-line granularity, achieving near-local performance with no programmer annotations.
+
+**Why notable** — Prior DSM systems required explicit data placement or suffered high coherence overhead; DRust shows that a language's ownership semantics can serve as a zero-overhead coherence protocol.
+
+[→ Read paper](https://www.usenix.org/conference/osdi24/presentation/ma-haoran)
+
+---
+
+### Nomad: Non-Exclusive Memory Tiering via Transactional Page Migration
+
+*Lingfeng Xiang, Zhen Lin, Weishu Deng, Hui Lu 0001 *et al.**
+
+**TL;DR** — Enables tiered-memory systems to migrate pages concurrently with ongoing accesses using a transactional protocol, eliminating the stop-the-world pauses of existing page-migration approaches.
+
+**Why notable** — CXL-based memory tiering is becoming essential for cost-effective cloud deployments; Nomad's non-exclusive migration is a key enabling mechanism for practical tiering at scale.
+
+[→ Read paper](https://www.usenix.org/conference/osdi24/presentation/xiang)
+
+---
+
+### Fast and Scalable In-network Lock Management Using Lock Fission
+
+*Hanze Zhang, Ke Cheng, Rong Chen 0001, Haibo Chen 0001*
+
+**TL;DR** — Splits a distributed lock into independent sub-locks held in programmable switches, allowing lock acquisition to complete in a single network round-trip without touching any server CPU.
+
+**Why notable** — Achieves latencies previously only possible with RDMA using commodity programmable switching hardware; the lock-fission abstraction generalises cleanly to other in-network coordination primitives.
+
+[→ Read paper](https://www.usenix.org/conference/osdi24/presentation/zhang-hanze)
+
+---
+
+### Chop Chop: Byzantine Atomic Broadcast to the Network Limit
+
+*Martina Camaioni, Rachid Guerraoui, Matteo Monti, Pierre-Louis Roman *et al.**
+
+**TL;DR** — Achieves Byzantine fault-tolerant atomic broadcast at near-network-bandwidth rates by batching, pipelining, and carefully overlapping cryptographic operations with network I/O.
+
+**Why notable** — Closes the gap between the theoretical throughput of BFT protocols and what commodity hardware can actually deliver; relevant baseline for any production BFT system design.
+
+[→ Read paper](https://www.usenix.org/conference/osdi24/presentation/camaioni)
+

site/content/cloud-edge/digests/OSDI-2025/index.md

@@ -0,0 +1,116 @@
+---
+title: OSDI 2025 Digest
+venue: OSDI
+year: 2025
+date: '2025-01-01'
+tags: []
+paper_count: 13
+draft: false
+---
+
+13 papers selected.
+
+---
+
+### Basilisk: Using Provenance Invariants to Automate Proofs of Undecidable Protocols
+
+*Tony Nuda Zhang, Keshav Singh, Tej Chajed, Manos Kapritsos *et al.**
+
+**TL;DR** — Automates the construction of correctness proofs for distributed protocols that were previously considered undecidable, advancing the state of the art in verified systems.
+
+---
+
+### Mako: Speculative Distributed Transactions with Geo-Replication
+
+*Weihai Shen, Yang Cui, Siddhartha Sen 0001, Sebastian Angel *et al.**
+
+**TL;DR** — Combines speculative execution with geo-replication to deliver low-latency distributed transactions without sacrificing consistency, addressing a fundamental tension in wide-area systems.
+
+---
+
+### Low End-to-End Latency atop a Speculative Shared Log with Fix-Ante Ordering
+
+*Shreesha G. Bhat, Tony Hong, Xuhao Luo, Jiyu Hu *et al.**
+
+**TL;DR** — Introduces fix-ante ordering to achieve low latency on a shared log without sacrificing throughput, offering a new design point for log-based distributed storage.
+
+---
+
+### Okapi: Decoupling Data Striping and Redundancy Grouping in Cluster File Systems
+
+*Sanjith Athlur, Timothy Kim, Saurabh Kadekodi, Francisco Maturana *et al.**
+
+**TL;DR** — Challenges a long-standing coupling in erasure-coded cluster file systems, enabling independent optimization of striping and redundancy with measurable gains in production workloads.
+
+---
+
+### PoWER Never Corrupts: Tool-Agnostic Verification of Crash Consistency and Corruption Detection
+
+*Hayley LeBlanc, Jacob R. Lorch, Chris Hawblitzel, Cheng Huang *et al.**
+
+**TL;DR** — Provides a tool-agnostic framework for formally verifying crash consistency and corruption detection in storage systems, raising the bar for storage software correctness.
+
+---
+
+### EMT: An OS Framework for New Memory Translation Architectures
+
+*Siyuan Chai 0001, Jiyuan Zhang 0003, Jongyul Kim 0001, Alan Wang *et al.**
+
+**TL;DR** — Defines an OS abstraction layer that decouples applications from hardware-specific memory translation mechanisms, enabling future memory architectures to be adopted without OS rewrites.
+
+---
+
+### XSched: Preemptive Scheduling for Diverse XPUs
+
+*Weihang Shen, Mingcong Han, Jialong Liu, Rong Chen 0001 *et al.**
+
+**TL;DR** — Generalises preemptive scheduling to heterogeneous accelerators (XPUs), providing a unified OS-level mechanism for fair and responsive multi-tenant accelerator sharing.
+
+---
+
+### Extending Applications Safely and Efficiently
+
+*Yusheng Zheng, Tong Yu, Yiwei Yang 0002, Yanpeng Hu *et al.**
+
+**TL;DR** — Presents a principled model for safe, efficient application extensibility that generalises beyond eBPF, with implications for the design of future OS extension mechanisms.
+
+---
+
+### NanoFlow: Towards Optimal Large Language Model Serving Throughput
+
+*Kan Zhu, Yufei Gao, Yilong Zhao 0002, Liangyu Zhao *et al.**
+
+**TL;DR** — Analytically characterises the throughput ceiling for LLM serving and proposes a system that approaches that bound through fine-grained intra-device parallelism.
+
+---
+
+### WaferLLM: Large Language Model Inference at Wafer Scale
+
+*Congjie He, Yeqi Huang, Pei Mu 0003, Ziming Miao *et al.**
+
+**TL;DR** — Demonstrates end-to-end LLM inference on wafer-scale hardware, tackling novel challenges in memory, communication, and fault tolerance at an unprecedented scale of integration.
+
+---
+
+### Mirage: A Multi-Level Superoptimizer for Tensor Programs
+
+*Mengdi Wu, Xinhao Cheng, Shengyu Liu, Chunan Shi *et al.**
+
+**TL;DR** — Extends tensor program superoptimisation to multiple abstraction levels, discovering non-obvious kernel fusions that outperform hand-tuned implementations for ML workloads.
+
+---
+
+### Training with Confidence: Catching Silent Errors in Deep Learning Training with Automated Proactive Checks
+
+*Yuxuan Jiang 0016, Ziming Zhou, Boyu Xu 0005, Beijie Liu *et al.**
+
+**TL;DR** — Addresses the underappreciated problem of silent hardware and software errors in large-scale DL training, providing automated proactive checks that catch failures before they corrupt long training runs.
+
+---
+
+### Compass: Encrypted Semantic Search with High Accuracy
+
+*Jinhao Zhu, Liana Patel, Matei Zaharia, Raluca Ada Popa*
+
+**TL;DR** — Enables accurate semantic (vector) search over encrypted data, bridging the gap between privacy-preserving computation and modern retrieval workloads in cloud-hosted RAG systems.
+

site/content/cloud-edge/digests/OSDI-2026/index.md

@@ -0,0 +1,13 @@
+---
+title: OSDI 2026 Digest
+venue: OSDI
+year: 2026
+date: '2026-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/SC-2024/index.md

@@ -0,0 +1,132 @@
+---
+title: SC 2024 Digest
+venue: SC
+year: 2024
+date: '2024-01-01'
+tags: []
+paper_count: 15
+draft: false
+---
+
+15 papers selected.
+
+---
+
+### Pushing the Limit of Quantum Mechanical Simulation to the Raman Spectra of a Biological System with 100 Million Atoms
+
+*Honghui Shang, Ying Liu 0055, Zhikun Wu, Zhenchuan Chen *et al.**
+
+**TL;DR** — Gordon Bell-class result scaling ab initio Raman spectroscopy to 100 million atoms, pushing quantum-chemical simulation well beyond prior limits.
+
+---
+
+### Breaking the Molecular Dynamics Timescale Barrier Using a Wafer-Scale System
+
+*Kylee Santos, Stan G. Moore, Tomas Oppelstrup, Amirali Sharifian *et al.**
+
+**TL;DR** — Demonstrates how a Cerebras wafer-scale engine shatters the classical MD timescale barrier, enabling microsecond-regime atomistic simulation at unprecedented speed.
+
+---
+
+### Scaling Molecular Dynamics with ab initio Accuracy to 149 Nanoseconds per Day
+
+*Jianxiong Li, Boyang Li, Zhuoqiang Guo, Mingzhen Li 0001 *et al.**
+
+**TL;DR** — Achieves 149 ns/day for large-scale deep-potential MD, combining neural-network potentials and HPC engineering to approach DFT accuracy at AIMD-like scale.
+
+---
+
+### Breaking the Million-Electron and 1 EFLOP/s Barriers: Biomolecular-Scale Ab Initio Molecular Dynamics Using MP2 Potentials
+
+*Ryan Stocks, Jorge L. Galvez Vallejo, Fiona C. Y. Yu, Calum Snowdon *et al.**
+
+**TL;DR** — First demonstration of MP2-level AIMD at the million-electron and exaFLOP/s scale, a landmark in quantum chemistry on supercomputers.
+
+---
+
+### Fire-Flyer AI-HPC: A Cost-Effective Software-Hardware Co-Design for Deep Learning
+
+*Wei An, Xiao Bi, Guanting Chen 0002, Shanhuang Chen *et al.**
+
+**TL;DR** — Full system co-design report from DeepSeek's AI-HPC cluster showing 40% cost reduction vs. NVIDIA DGX through network/software optimizations, with production evidence at scale.
+
+---
+
+### MProt-DPO: Breaking the ExaFLOPS Barrier for Multimodal Protein Design Workflows with Direct Preference Optimization
+
+*Gautham Dharuman, Kyle Hippe, Alexander Brace, Sam Foreman *et al.**
+
+**TL;DR** — First exaFLOP/s AI science workflow, integrating multimodal protein design with DPO alignment at supercomputing scale across Frontier and Aurora.
+
+---
+
+### ORBIT: Oak Ridge Base Foundation Model for Earth System Predictability
+
+*Xiao Wang 0004, Siyan Liu, Aristeidis Tsaris, Jong-Youl Choi *et al.**
+
+**TL;DR** — Introduces a large foundation model for Earth system prediction trained on Frontier, demonstrating how exascale AI infrastructure enables climate-scale spatiotemporal modeling.
+
+---
+
+### Democratizing AI: Open-source Scalable LLM Training on GPU-based Supercomputers
+
+*Siddharth Singh, Prajwal Singhania, Aditya K. Ranjan, John Kirchenbauer *et al.**
+
+**TL;DR** — Presents an open-source framework for LLM training at thousands-of-GPU scale, systematically analyzing throughput, memory, and communication trade-offs on leadership supercomputers.
+
+---
+
+### Exploring GPU-to-GPU Communication: Insights into Supercomputer Interconnects
+
+*Daniele De Sensi, Lorenzo Pichetti, Flavio Vella, Tiziano De Matteis *et al.**
+
+**TL;DR** — Comprehensive empirical study of GPU-to-GPU communication across six major supercomputers, revealing bottlenecks and bandwidth characteristics relevant to all distributed AI/HPC workloads.
+
+---
+
+### Network-Offloaded Bandwidth-Optimal Broadcast and Allgather for Distributed AI
+
+*Mikhail Khalilov, Salvatore Di Girolamo, Marcin Chrapek, Rami Nudelman *et al.**
+
+**TL;DR** — Achieves bandwidth-optimal collective communication by offloading broadcast and allgather to SmartNICs, directly benefiting large-scale distributed deep learning.
+
+---
+
+### A Workflow Roofline Model for End-to-End Workflow Performance Analysis
+
+*Nan Ding 0006, Brian Austin, Yang Liu 0179, Neil Mehta *et al.**
+
+**TL;DR** — Extends the Roofline model to full end-to-end HPC workflows, enabling systematic performance diagnosis across compute, I/O, and data movement stages.
+
+---
+
+### GVARP: Detecting Performance Variance on Large-Scale Heterogeneous Systems
+
+*Xin You 0001, Zhibo Xuan, Hailong Yang 0002, Zhongzhi Luan *et al.**
+
+**TL;DR** — Identifies and diagnoses GPU performance variance at scale on heterogeneous supercomputers, an increasingly critical issue for reproducibility and efficiency.
+
+---
+
+### A Digital Twin Framework for Liquid-cooled Supercomputers as Demonstrated at Exascale
+
+*Wesley Brewer, Matthias Maiterth, Vineet Kumar, Rafal P. Wojda *et al.**
+
+**TL;DR** — First deployment of a digital twin for a liquid-cooled exascale system (Frontier), enabling real-time thermal and power management with validated empirical results.
+
+---
+
+### Doubling Graph Traversal Efficiency to 198 TeraTEPS on the Supercomputer Fugaku
+
+*Junya Arai, Masahiro Nakao, Yuto Inoue, Kanto Teranishi *et al.**
+
+**TL;DR** — Sets a new world record for graph traversal at 198 TTEPS on Fugaku through novel communication and load-balancing techniques, a landmark Graph500 result.
+
+---
+
+### MegaMmap: Blurring the Boundary Between Memory and Storage for Data-Intensive Workloads
+
+*Luke Logan, Anthony Kougkas, Xian-He Sun*
+
+**TL;DR** — Novel storage abstraction that transparently tiered memory and storage hierarchies, delivering near-DRAM performance for data-intensive HPC and AI workloads.
+

site/content/cloud-edge/digests/SC-2025/index.md

@@ -0,0 +1,132 @@
+---
+title: SC 2025 Digest
+venue: SC
+year: 2025
+date: '2025-01-01'
+tags: []
+paper_count: 15
+draft: false
+---
+
+15 papers selected.
+
+---
+
+### Cosmological Hydrodynamics at Exascale: A Trillion-Particle Leap in Capability
+
+*Nicholas Frontiere, J. D. Emberson, Michael Buehlmann, Esteban M. Rangel *et al.**
+
+**TL;DR** — Delivers the first trillion-particle cosmological hydrodynamics simulation on exascale hardware, demonstrating sustained petaflop-scale performance on a flagship scientific application.
+
+---
+
+### Ab-initio Quantum Transport with the GW Approximation, 42, 240 Atoms, and Sustained Exascale Performance
+
+*Nicolas Vetsch, Alexander Maeder, Vincent Maillou, Anders Winka *et al.**
+
+**TL;DR** — Achieves sustained exascale performance for first-principles quantum transport at 42,240 atoms, establishing a new scale record for the GW many-body perturbation method.
+
+---
+
+### Kilometer-Scale AI-Powered and Performance-Portable Earth System Model (AP3ESM) to Achieve Year-Scale Simulation Speed on Heterogeneous Supercomputers
+
+*Kai Xu, Maoxue Yu, Yuhu Chen, Jie Gao *et al.**
+
+**TL;DR** — Integrates AI acceleration into a kilometer-scale climate model to reach year-scale simulation throughput, showing how ML–physics hybrid approaches can redefine climate modeling at supercomputer scale.
+
+---
+
+### Uno: A One-Stop Solution for Inter- and Intra-Data Center Congestion Control and Reliable Connectivity
+
+*Tommaso Bonato, Sepehr Abdous, Abdul Kabbani, Ahmad Ghalayini *et al.**
+
+**TL;DR** — Proposes a unified congestion control and reliable transport architecture spanning intra- and inter-datacenter links, with strong throughput and latency results relevant to AI and HPC clusters.
+
+---
+
+### SDR-RDMA: Software-Defined Reliability Architecture for Planetary Scale RDMA Communication
+
+*Mikhail Khalilov, Siyuan Shen, Marcin Chrapek, Tiancheng Chen *et al.**
+
+**TL;DR** — Introduces software-defined reliability for RDMA at global scale, decoupling reliability policies from hardware to dramatically improve fault tolerance and reconfigurability in large-scale HPC networks.
+
+---
+
+### Bine Trees: Enhancing Collective Operations by Optimizing Communication Locality
+
+*Daniele De Sensi, Saverio Pasqualoni, Lorenzo Piarulli, Tommaso Bonato *et al.**
+
+**TL;DR** — Presents bine tree topologies for MPI collective operations that exploit communication locality, yielding significant latency and bandwidth improvements over standard binomial trees on modern HPC interconnects.
+
+---
+
+### STELLAR: Storage Tuning Engine Leveraging LLM Autonomous Reasoning for High Performance Parallel File Systems
+
+*Chris Egersdoerfer, Philip H. Carns, Shane Snyder, Robert Ross *et al.**
+
+**TL;DR** — Demonstrates that an LLM-driven autonomous reasoning engine can tune parallel file system parameters as effectively as expert hand-tuning, opening a new direction for self-optimizing HPC storage.
+
+---
+
+### Phoenix: A Refactored I/O Stack for GPU Direct Storage without Phony Buffers
+
+*Jianqin Yan, Shi Qiu 0012, Yina Lv, Yifan Hu *et al.**
+
+**TL;DR** — Redesigns the GPU direct storage I/O stack to eliminate staging buffers, achieving large bandwidth gains for GPU-to-SSD transfers critical to LLM training and scientific data workflows.
+
+---
+
+### Breaking the System Noise Barrier at Exascale
+
+*Edgar A. León, Joseph Glenski, Mark J. Stock, Kim H. McMahon *et al.**
+
+**TL;DR** — Provides a rigorous characterization and mitigation of OS and hardware noise at exascale, demonstrating measurable improvements in collective communication performance on a real production system.
+
+---
+
+### Story of Two GPUs: Characterizing the Resilience of Hopper H100 and Ampere A100 GPUs
+
+*Shengkun Cui, Archit Patke, Hung Nguyen, Aditya Ranjan *et al.**
+
+**TL;DR** — Delivers the first detailed side-by-side hardware fault-injection study of H100 and A100 GPUs, revealing how architecture changes in Hopper alter error propagation and resilience for HPC and AI workloads.
+
+---
+
+### Exploring and Mitigating Failure Behavior of Large Language Model Training Workloads in HPC Systems
+
+*Pengfei Yu 0002, Jingjing Gu, Hao Han, Dazhong Shen *et al.**
+
+**TL;DR** — Characterizes real-world failure modes of large-scale LLM training on HPC clusters and proposes targeted mitigation strategies, providing essential reliability insights for AI infrastructure operators.
+
+---
+
+### XaaS Containers: Performance-Portable Representation With Source and IR Containers
+
+*Marcin Copik, Eiman Alnuaimi, Alok Kamatar, Valérie Hayot-Sasson *et al.**
+
+**TL;DR** — Proposes source- and IR-level HPC containers that enable performance portability across heterogeneous architectures without recompilation, addressing a key deployment challenge for reproducible HPC software.
+
+---
+
+### cMPI: Using CXL Memory Sharing for MPI One-Sided and Two-Sided Inter-Node Communications
+
+*Xi Wang 0027, Bin Ma, Jongryool Kim, Byungil Koh *et al.**
+
+**TL;DR** — Exploits CXL memory semantics to implement MPI communication primitives with dramatically reduced software overhead, demonstrating a promising path for memory-centric supercomputer interconnects.
+
+---
+
+### X-MoE: Enabling Scalable Training for Emerging Mixture-of-Experts Architectures on HPC Platforms
+
+*Yueming Yuan, Ahan Gupta, Jianping Li, Sajal Dash *et al.**
+
+**TL;DR** — Addresses the communication and load-balance bottlenecks of sparse Mixture-of-Experts training at scale, achieving efficient utilization of large GPU clusters for next-generation LLM workloads.
+
+---
+
+### Benchmark-driven Models for Energy Analysis and Attribution of GPU-Accelerated Supercomputing
+
+*Oscar Antepara, Zhengji Zhao, Brian Austin, Nan Ding 0006 *et al.**
+
+**TL;DR** — Develops fine-grained benchmark-driven energy models for GPU supercomputers that attribute power consumption to individual components and workloads, enabling principled energy optimization at the facility level.
+

site/content/cloud-edge/digests/SC-2026/index.md

@@ -0,0 +1,13 @@
+---
+title: SC 2026 Digest
+venue: SC
+year: 2026
+date: '2026-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/SEC-2024/index.md

@@ -0,0 +1,108 @@
+---
+title: SEC 2024 Digest
+venue: SEC
+year: 2024
+date: '2024-01-01'
+tags: []
+paper_count: 12
+draft: false
+---
+
+12 papers selected.
+
+---
+
+### EdgeCore: Resource Dependency-Aware Multi-Tenant Orchestration for Mobile Edge Clouds
+
+*Amran Haroon*
+
+**TL;DR** — Introduces a multi-tenant edge orchestration system that captures resource dependencies across co-located workloads, demonstrating significant improvements in task completion latency and resource utilization.
+
+---
+
+### Righteous: Automatic Right-Sizing for Complex Edge Deployments
+
+*Aniruddha Rakshit*
+
+**TL;DR** — Presents an automated right-sizing framework for edge deployments that dynamically adjusts resource allocations to match workload demands without manual intervention.
+
+---
+
+### Colibri: Efficient Collection of Fine-Grained Resource Metrics Necessary for Mobile Edge Computing
+
+*Ke-Jou Hsu*
+
+**TL;DR** — Proposes a low-overhead monitoring system for collecting fine-grained resource metrics at the edge, enabling more accurate profiling for MEC scheduling decisions.
+
+---
+
+### HyperDrive: Scheduling Serverless Functions in the Edge-Cloud-Space 3D Continuum
+
+*Thomas W. Pusztai*
+
+**TL;DR** — Extends serverless scheduling across a three-dimensional edge-cloud-space continuum, addressing latency and resource constraints introduced by satellite and terrestrial tiers.
+
+---
+
+### Falcon: Live Reconfiguration for Stateful Stream Processing on the Edge
+
+*Pritish Mishra*
+
+**TL;DR** — Enables live, low-disruption reconfiguration of stateful stream processing pipelines at the edge, minimizing downtime during topology changes.
+
+---
+
+### FusedInf: Efficient Swapping of DNN Models for On-Demand Serverless Inference Services on the Edge
+
+*Sifat Ut Taki*
+
+**TL;DR** — Reduces cold-start latency for serverless DNN inference at the edge by fusing model loading with active inference through selective layer swapping.
+
+---
+
+### EcoEdgeInfer: Dynamically Optimizing Latency and Sustainability for Inference on Edge Devices
+
+*Sri Pramodh Rachuri*
+
+**TL;DR** — Co-optimizes inference latency and energy sustainability on edge devices by dynamically trading off accuracy and hardware utilization under carbon-aware constraints.
+
+---
+
+### Elastic Execution of Multi-Tenant DNNs on Heterogeneous Edge MPSoCs
+
+*Soroush Heidari*
+
+**TL;DR** — Demonstrates elastic, interference-aware co-execution of multiple DNNs across heterogeneous processing elements in edge MPSoCs to maximize throughput and fairness.
+
+---
+
+### Optimizing Edge Offloading Decisions for Object Detection
+
+*Jiaming Qiu*
+
+**TL;DR** — Formulates and solves an online offloading decision problem for object detection that jointly minimizes latency and energy consumption under variable network conditions.
+
+---
+
+### VideoJam: Self-Balancing Architecture for Live Video Analytics
+
+*Youssouph Faye*
+
+**TL;DR** — Proposes a self-balancing edge architecture for live video analytics that dynamically redistributes pipeline stages to prevent bottlenecks under fluctuating camera workloads.
+
+---
+
+### OVIDA: Orchestrator for Video Analytics on Disaggregated Architecture
+
+*Manavjeet Singh*
+
+**TL;DR** — Designs an orchestration layer for disaggregated edge hardware that places and migrates video analytics microservices to exploit spatial locality and heterogeneous accelerators.
+
+---
+
+### TA-ASF: Attention-Sensitive Token Sampling and Fusing for Visual Transformer Models on the Edge
+
+*Junquan Chen*
+
+**TL;DR** — Accelerates Vision Transformer inference at the edge by pruning and fusing attention tokens based on saliency, achieving accuracy-efficiency trade-offs suitable for resource-constrained devices.
+

site/content/cloud-edge/digests/SEC-2025/index.md

@@ -0,0 +1,108 @@
+---
+title: SEC 2025 Digest
+venue: SEC
+year: 2025
+date: '2025-01-01'
+tags: []
+paper_count: 12
+draft: false
+---
+
+12 papers selected.
+
+---
+
+### lm-Meter: Unveiling Runtime Inference Latency for On-Device Language Models
+
+*Haoxin Wang 0003*
+
+**TL;DR** — Provides the first detailed runtime profiling framework for on-device LLM inference, revealing key latency bottlenecks across diverse edge hardware configurations.
+
+---
+
+### SLED: A Speculative LLM Decoding Framework for Efficient Edge Serving
+
+*Xiangchen Li*
+
+**TL;DR** — Adapts speculative decoding to edge serving constraints, reducing LLM token generation latency while respecting the tight memory and compute budgets of edge nodes.
+
+---
+
+### SledgeScale: Load-Aware Dispatch and Deadline-Driven Scheduling for Scalable, Dense Serverless Computing in Edge Data Centers
+
+*Xiaosu Lyu*
+
+**TL;DR** — Introduces a load-aware dispatch and deadline-driven scheduler for dense serverless edge data centers, demonstrating substantial SLA compliance improvements over baseline policies.
+
+---
+
+### Warping the Edge: Enabling Instant Mobility for Stateful Applications over 5G and Beyond
+
+*Mukhtiar Ahmad*
+
+**TL;DR** — Achieves near-instantaneous stateful application migration across 5G edge nodes by combining memory snapshotting with network-layer forwarding continuity.
+
+---
+
+### Uncertainty-Aware RL-Based Scheduling of Multi-DNN Workloads on Edge MPSoCs
+
+*Soroush Heidari*
+
+**TL;DR** — Uses uncertainty-aware reinforcement learning to schedule concurrent DNN workloads on heterogeneous edge MPSoCs, reducing deadline misses under dynamic arrival patterns.
+
+---
+
+### SEEB-GPU: Early-Exit Aware Scheduling and Batching for Edge GPU Inference
+
+*Srinivasan Subramaniyan*
+
+**TL;DR** — Exploits early-exit branching in DNN inference to build an adaptive batching and scheduling policy for edge GPUs that cuts average latency without sacrificing throughput.
+
+---
+
+### Elastoformer: Enabling Dynamic Adaptivity via Elastic Model Transformation
+
+*Sudaksh Kalra*
+
+**TL;DR** — Proposes elastic transformer transformations that resize model capacity at runtime to match available edge resources, enabling continuous inference under fluctuating conditions.
+
+---
+
+### PlatformX: An End-to-End Transferable Platform for Energy-Efficient Neural Architecture Search
+
+*Xiaolong Tu*
+
+**TL;DR** — Presents a transferable NAS platform that searches for energy-efficient DNN architectures deployable across heterogeneous edge targets with minimal re-search overhead.
+
+---
+
+### Bayes-Split-Edge: Bayesian Optimization for Constrained Collaborative Inference in Wireless Edge Systems
+
+*Fatemeh Zahra Safaeipour*
+
+**TL;DR** — Applies Bayesian optimization to find optimal split points for collaborative inference in wireless edge systems, accounting for dynamic channel and computation constraints.
+
+---
+
+### Energy-efficient DNN Dividing Technique for Latency Optimization in Dynamic Mobile Edge Networks
+
+*Eldiyar Zhantileuov*
+
+**TL;DR** — Develops a DNN partitioning strategy for mobile edge networks that minimizes end-to-end latency while satisfying energy budgets under time-varying link conditions.
+
+---
+
+### LLM-Driven Auto Configuration for Transient IoT Device Collaboration
+
+*Hetvi Shastri*
+
+**TL;DR** — Leverages LLMs to automate the configuration of transient IoT device coalitions, reducing manual setup overhead and adapting collaboration policies to changing device membership.
+
+---
+
+### fReeLoaders: An IoT Ecosystem for Real-Time Deadline-Driven Task Scheduling using Reinforcement Learning
+
+*Marshall Clyburn*
+
+**TL;DR** — Builds a reinforcement-learning scheduler for IoT ecosystems that meets real-time task deadlines by exploiting opportunistic idle capacity across heterogeneous edge devices.
+

site/content/cloud-edge/digests/SEC-2026/index.md

@@ -0,0 +1,13 @@
+---
+title: SEC 2026 Digest
+venue: SEC
+year: 2026
+date: '2026-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/SOSP-2024/index.md

@@ -0,0 +1,176 @@
+---
+title: SOSP 2024 Digest
+venue: SOSP
+year: 2024
+date: '2024-11-05'
+tags:
+- operating-systems
+- distributed-systems
+- storage
+- cloud
+- formal-verification
+- ml-systems
+- security
+- serverless
+paper_count: 13
+draft: false
+---
+
+13 papers selected.
+
+---
+
+### Verus: A Practical Foundation for Systems Verification
+
+*Andrea Lattuada 0001, Travis Hance, Jay Bosamiya, Matthias Brun 0002 *et al.**
+
+**TL;DR** — Verus is a Rust-based verification framework that makes formal proofs of low-level systems code tractable at scale, covering memory safety, functional correctness, and concurrency.
+
+**Why notable** — Formal verification of real systems code has long been impractical; Verus closes the usability gap by integrating SMT-based proofs directly into a systems programming language, making it the most broadly applicable verification tool for the OS community to date.
+
+[→ Read paper](https://doi.org/10.1145/3694715.3695952)
+
+---
+
+### Modular Verification of Secure and Leakage-Free Systems: From Application Specification to Circuit-Level Implementation
+
+*Anish Athalye, Henry Corrigan-Gibbs, M. Frans Kaashoek, Joseph Tassarotti *et al.**
+
+**TL;DR** — A modular verification methodology lets developers prove end-to-end that a system leaks no sensitive information, bridging the gap from high-level spec all the way to circuit-level hardware behavior.
+
+**Why notable** — Side-channel leakage across abstraction layers is notoriously hard to reason about; this work provides a principled, mechanized framework to do so, setting a new bar for hardware-software co-verification of secure systems.
+
+[→ Read paper](https://doi.org/10.1145/3694715.3695956)
+
+---
+
+### Autobahn: Seamless high speed BFT
+
+*Neil Giridharan, Florian Suri-Payer, Ittai Abraham, Lorenzo Alvisi *et al.**
+
+**TL;DR** — Autobahn is a BFT consensus protocol that achieves high throughput under normal operation while seamlessly falling back to a slow path during faults, eliminating the throughput cliff common in prior BFT designs.
+
+**Why notable** — Byzantine fault-tolerant systems have historically traded peak performance for safety margins; Autobahn's seamless transition between fast and slow paths closes that gap and is likely to influence the next generation of production BFT deployments.
+
+[→ Read paper](https://doi.org/10.1145/3694715.3695942)
+
+---
+
+### Fast, Flexible, and Practical Kernel Extensions
+
+*Kumar Kartikeya Dwivedi, Rishabh R. Iyer, Sanidhya Kashyap*
+
+**TL;DR** — A new kernel extension framework surpasses eBPF's safety and flexibility constraints by using a combination of ahead-of-time compilation and a lean verification layer, enabling complex kernel extensions with near-native performance.
+
+**Why notable** — eBPF has become ubiquitous for in-kernel programmability, but its verifier fundamentally limits expressiveness; this work re-examines those trade-offs and offers a path toward richer, safer kernel extensions with broad applicability to networking, tracing, and storage.
+
+[→ Read paper](https://doi.org/10.1145/3694715.3695950)
+
+---
+
+### Tiered Memory Management: Access Latency is the Key!
+
+*Midhul Vuppalapati, Rachit Agarwal 0001*
+
+**TL;DR** — A principled tiered-memory manager that tracks per-page access latency rather than access frequency achieves substantially better performance for modern workloads on heterogeneous DRAM/CXL/NVM memory hierarchies.
+
+**Why notable** — As CXL-attached memory becomes mainstream, frequency-based page migration policies inherited from NUMA systems are increasingly inadequate; this paper reframes the problem around latency and provides a practical, deployable design.
+
+[→ Read paper](https://doi.org/10.1145/3694715.3695968)
+
+---
+
+### Fast & Safe IO Memory Protection
+
+*Benny Rubin, Saksham Agarwal, Qizhe Cai, Rachit Agarwal 0001*
+
+**TL;DR** — A hardware-software co-design eliminates the performance overhead of IOMMU-based DMA isolation by allowing safe, fine-grained IO memory protection without full page-table walks on the critical path.
+
+**Why notable** — DMA attacks remain a real threat yet IOMMU protection is widely disabled in production because of latency costs; this work makes protection affordable and is directly relevant to cloud, NIC, and storage subsystem designers.
+
+[→ Read paper](https://doi.org/10.1145/3694715.3695943)
+
+---
+
+### SWARM: Replicating Shared Disaggregated-Memory Data in No Time
+
+*Antoine Murat, Clément Burgelin, Athanasios Xygkis, Igor Zablotchi *et al.**
+
+**TL;DR** — SWARM replicates data in disaggregated-memory clusters with near-zero latency overhead by exploiting one-sided RDMA operations and a carefully designed protocol that avoids coordination on the read path.
+
+**Why notable** — Disaggregated memory is an emerging data-center architecture; providing fault tolerance without sacrificing its key latency advantage is an open problem, and SWARM's approach is both novel and practically relevant.
+
+[→ Read paper](https://doi.org/10.1145/3694715.3695945)
+
+---
+
+### Morph: Efficient File-Lifetime Redundancy Management for Cluster File Systems
+
+*Timothy Kim, Sanjith Athlur, Saurabh Kadekodi, Francisco Maturana *et al.**
+
+**TL;DR** — Morph dynamically transitions files through redundancy schemes (replication → erasure coding) based on observed file age and access patterns, substantially reducing storage overhead in large-scale cluster file systems.
+
+**Why notable** — Static redundancy policies waste significant capacity in practice; Morph's lifecycle-aware approach is validated at Google scale and provides a compelling template for storage systems serving diverse workloads.
+
+[→ Read paper](https://doi.org/10.1145/3694715.3695981)
+
+---
+
+### PowerInfer: Fast Large Language Model Serving with a Consumer-grade GPU
+
+*Yixin Song, Zeyu Mi, Haotong Xie, Haibo Chen 0001*
+
+**TL;DR** — PowerInfer exploits the activation sparsity of LLMs to partition computation between a consumer GPU and CPU, achieving high inference throughput without data-center hardware.
+
+**Why notable** — Democratizing LLM inference beyond cloud hardware is a pressing systems challenge; PowerInfer's sparsity-aware approach delivers surprising performance on commodity hardware and has already influenced a wave of follow-on work.
+
+[→ Read paper](https://doi.org/10.1145/3694715.3695964)
+
+---
+
+### LoongServe: Efficiently Serving Long-Context Large Language Models with Elastic Sequence Parallelism
+
+*Bingyang Wu, Shengyu Liu, Yinmin Zhong, Peng Sun 0006 *et al.**
+
+**TL;DR** — LoongServe introduces elastic sequence parallelism that dynamically adjusts the number of workers handling each long-context request to minimize GPU idle time and satisfy latency SLOs.
+
+**Why notable** — Long-context inference strains fixed parallelism strategies, creating severe resource fragmentation; LoongServe's elasticity primitive addresses this gap and is directly applicable to production LLM serving infrastructure.
+
+[→ Read paper](https://doi.org/10.1145/3694715.3695948)
+
+---
+
+### Unifying serverless and microservice workloads with SigmaOS
+
+*Ariel Szekely, Adam Belay, Robert Morris 0005, M. Frans Kaashoek*
+
+**TL;DR** — SigmaOS is an OS-level abstraction that treats serverless functions and microservices as first-class, interchangeable computational units, simplifying resource management and improving utilization for mixed workloads.
+
+**Why notable** — The artificial split between serverless and microservice programming models imposes significant operational complexity; SigmaOS's unified abstraction from the MIT systems group offers a clean architectural answer with demonstrated performance gains.
+
+[→ Read paper](https://doi.org/10.1145/3694715.3695947)
+
+---
+
+### Cookie Monster: Efficient On-Device Budgeting for Differentially-Private Ad-Measurement Systems
+
+*Pierre Tholoniat, Kelly Kostopoulou, Peter McNeely, Prabhpreet Singh Sodhi *et al.**
+
+**TL;DR** — Cookie Monster implements practical on-device differential-privacy budget management for ad attribution, showing that strong privacy guarantees can be enforced locally without destroying ad-measurement utility.
+
+**Why notable** — Browser vendors are actively replacing third-party cookies with privacy-preserving attribution APIs; this paper provides rigorous analysis of the privacy-utility trade-off and offers deployable techniques relevant to both industry standards and future OS-level privacy primitives.
+
+[→ Read paper](https://doi.org/10.1145/3694715.3695965)
+
+---
+
+### Efficient Reproduction of Fault-Induced Failures in Distributed Systems with Feedback-Driven Fault Injection
+
+*Jia Pan, Haoze Wu, Tanakorn Leesatapornwongsa, Suman Nath *et al.**
+
+**TL;DR** — A feedback-guided fault injection framework automatically reproduces complex distributed-system failures triggered by rare fault combinations, dramatically reducing the manual effort needed to diagnose and fix them.
+
+**Why notable** — Fault-induced failures in distributed systems are notoriously hard to reproduce; the paper's closed-loop search strategy is a methodological advance for reliability testing and is likely to influence both academic research and industrial chaos-engineering tools.
+
+[→ Read paper](https://doi.org/10.1145/3694715.3695979)
+

site/content/cloud-edge/digests/SOSP-2025/index.md

@@ -0,0 +1,124 @@
+---
+title: SOSP 2025 Digest
+venue: SOSP
+year: 2025
+date: '2025-01-01'
+tags: []
+paper_count: 14
+draft: false
+---
+
+14 papers selected.
+
+---
+
+### LithOS: An Operating System for Efficient Machine Learning on GPUs
+
+*Patrick H. Coppock, Brian Zhang, Eliot H. Solomon, Vasilis Kypriotis *et al.**
+
+**TL;DR** — Designs a dedicated OS for GPU ML workloads, rethinking scheduling and resource management at the kernel level for accelerator-centric computing.
+
+---
+
+### CHERIoT RTOS: An OS for Fine-Grained Memory-Safe Compartments on Low-Cost Embedded Devices
+
+*Saar Amar, Tony Chen, David Chisnall, Nathaniel Wesley Filardo *et al.**
+
+**TL;DR** — Demonstrates hardware-capability-based fine-grained memory safety and compartmentalisation on constrained embedded devices, setting a new bar for secure IoT OSes.
+
+---
+
+### Atmosphere: Practical Verified Kernels with Rust and Verus
+
+*Xiangdong Chen, Zhaofeng Li 0004, Jerry Zhang, Vikram Narayanan *et al.**
+
+**TL;DR** — Shows that practical kernel verification is achievable using Rust and the Verus verifier, bridging the gap between formal methods and production OS development.
+
+---
+
+### TickTock: Verified Isolation in a Production Embedded OS
+
+*Vivien Rindisbacher, Evan Johnson 0001, Nico Lehmann, Tyler Potyondy *et al.**
+
+**TL;DR** — Delivers machine-checked proofs of isolation properties for a real embedded OS, providing strong security guarantees without sacrificing production deployability.
+
+---
+
+### μFork: Supporting POSIX fork Within a Single-Address-Space OS
+
+*John Alistair Kressel, Hugo Lefeuvre, Pierre Olivier*
+
+**TL;DR** — Reconciles the POSIX fork abstraction with unikernel/single-address-space designs, addressing a long-standing compatibility obstacle for library OS deployments.
+
+---
+
+### Scalable Address Spaces using Concurrent Interval Skiplist
+
+*Tae Woo Kim, Youngjin Kwon, Jeehoon Kang*
+
+**TL;DR** — Tackles the fundamental kernel scalability problem of virtual memory area management by replacing the VMA red-black tree with a concurrent interval skiplist, yielding significant mmap/munmap throughput gains.
+
+---
+
+### cache_ext: Customizing the Page Cache with eBPF
+
+*Tal Zussman, Ioannis Zarkadas, Jeremy Carin, Andrew Cheng *et al.**
+
+**TL;DR** — Extends the eBPF programmability model to the OS page cache, enabling application-specific caching policies without kernel modifications.
+
+---
+
+### Aeolia: A Fast and Secure Userspace Interrupt-Based Storage Stack
+
+*Chuandong Li 0004, Ran Yi 0004, Zonghao Zhang, Jing Liu 0074 *et al.**
+
+**TL;DR** — Redesigns the storage I/O path around userspace interrupts, achieving high throughput and low latency while preserving strong isolation properties.
+
+---
+
+### Sleeping with One Eye Open: Fast, Sustainable Storage with Sandman
+
+*Yanbo Zhou, Erci Xu, Anisa Su, Jim Harris *et al.**
+
+**TL;DR** — Introduces a storage system that aggressively power-gates flash devices while maintaining low latency, addressing sustainability concerns for large-scale storage deployments.
+
+---
+
+### Oasis: Pooling PCIe Devices Over CXL to Boost Utilization
+
+*Yuhong Zhong, Daniel S. Berger, Pantea Zardoshti, Enrique Saurez *et al.**
+
+**TL;DR** — Exploits CXL interconnects to pool PCIe devices across servers, significantly improving device utilisation and laying groundwork for memory-semantic datacenter architectures.
+
+---
+
+### Scalable Far Memory: Balancing Faults and Evictions
+
+*Yueyang Pan, Yash Lala, Musa Unal, Yujie Ren *et al.**
+
+**TL;DR** — Provides a rigorous analysis of the fault-vs-eviction trade-off in far-memory systems and proposes mechanisms that scale to production datacenter workloads.
+
+---
+
+### Tiga: Accelerating Geo-Distributed Transactions with Synchronized Clocks
+
+*Jinkun Geng, Shuai Mu 0001, Anirudh Sivaraman, Balaji Prabhakar*
+
+**TL;DR** — Exploits hardware clock synchronisation to cut coordination overhead in geo-distributed transactions, achieving latency close to the theoretical network minimum.
+
+---
+
+### Pesto: Cooking up High Performance BFT Queries
+
+*Florian Suri-Payer, Neil Giridharan, Liam Arzola, Shir Cohen *et al.**
+
+**TL;DR** — Advances Byzantine fault-tolerant systems by separating the query path from consensus, enabling high-throughput reads without weakening safety guarantees.
+
+---
+
+### Orthrus: Efficient and Timely Detection of Silent User Data Corruption in the Cloud with Resource-Adaptive Computation Validation
+
+*Chenxiao Liu, Zhenting Zhu, Quanxi Li, Yanwen Xia *et al.**
+
+**TL;DR** — Detects silent data corruption at cloud scale using resource-adaptive redundant computation, addressing a critical and hard-to-diagnose reliability threat in hyperscale infrastructure.
+

site/content/cloud-edge/digests/SOSP-2026/index.md

@@ -0,0 +1,13 @@
+---
+title: SOSP 2026 Digest
+venue: SOSP
+year: 2026
+date: '2026-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/SoCC-2024/index.md

@@ -0,0 +1,158 @@
+---
+title: SoCC 2024 Digest
+venue: SoCC
+year: 2024
+date: '2024-11-01'
+tags:
+- cloud-computing
+- distributed-systems
+paper_count: 12
+draft: false
+---
+
+12 papers selected.
+
+---
+
+### Queue Management for SLO-Oriented Large Language Model Serving
+
+*Archit Patke, Dhemath Reddy, Saurabh Jha, Haoran Qiu *et al.**
+
+**TL;DR** — A queue management framework that enforces latency SLOs for LLM serving by dynamically routing and prioritizing requests across heterogeneous inference capacity.
+
+**Why notable** — As LLM deployments move into production clouds, meeting strict time-to-first-token and total latency SLOs becomes critical; this work directly addresses that gap with a practical, deployable solution. It is one of the first papers to treat LLM serving as a cloud SLO-management problem rather than a pure model-optimization problem.
+
+[→ Read paper](https://doi.org/10.1145/3698038.3698523)
+
+---
+
+### Kale: Elastic GPU Scheduling for Online DL Model Training
+
+*Ziyang Liu, Renyu Yang, Jin Ouyang, Weihan Jiang *et al.**
+
+**TL;DR** — Kale elastically resizes GPU allocations for online DL training jobs in response to real-time resource pressure, improving cluster utilization without violating training progress guarantees.
+
+**Why notable** — Elastic GPU scheduling is an unsolved pain point in shared ML clusters; Kale's ability to dynamically shrink and expand jobs without checkpointing overhead is directly applicable to production training infrastructure at hyperscalers.
+
+[→ Read paper](https://doi.org/10.1145/3698038.3698532)
+
+---
+
+### Hops: Fine-grained heterogeneous sensing, efficient and fair Deep Learning cluster scheduling system
+
+*Qinghe Wang, Futian Wang, Xinwei Zheng*
+
+**TL;DR** — Hops uses fine-grained, heterogeneity-aware GPU sensing to make scheduling decisions that are simultaneously efficient and fair across diverse DL workloads.
+
+**Why notable** — Hardware heterogeneity in GPU clusters is the norm, not the exception; Hops provides a principled framework for exploiting that diversity, making it immediately relevant to operators of mixed-generation GPU fleets.
+
+[→ Read paper](https://doi.org/10.1145/3698038.3698515)
+
+---
+
+### Process-as-a-Service: Unifying Elastic and Stateful Clouds with Serverless Processes
+
+*Marcin Copik, Alexandru Calotoiu, Gyorgy Réthy, Roman Böhringer *et al.**
+
+**TL;DR** — PraaS introduces a long-lived, stateful serverless process abstraction that bridges the gap between ephemeral FaaS functions and persistent cloud VMs.
+
+**Why notable** — Statelessness is the central limitation of today's FaaS platforms; this paper proposes a well-grounded new programming model that could reshape how developers think about serverless, backed by implementation and evaluation at scale.
+
+[→ Read paper](https://doi.org/10.1145/3698038.3698567)
+
+---
+
+### FaPES: Enabling Efficient Elastic Scaling for Serverless Machine Learning Platforms
+
+*Xiaoyang Zhao 0005, Siran Yang, Jiamang Wang, Lansong Diao *et al.**
+
+**TL;DR** — FaPES achieves fast, fine-grained vertical and horizontal scaling of serverless ML serving pods by decoupling memory provisioning from compute allocation.
+
+**Why notable** — Elastic scaling for ML inference is a key cost driver in cloud ML platforms; FaPES demonstrates sub-second scaling decisions that reduce both cold-start overhead and resource waste, with results from a production deployment.
+
+[→ Read paper](https://doi.org/10.1145/3698038.3698548)
+
+---
+
+### Faascale: Scaling MicroVM Vertically for Serverless Computing with Memory Elasticity
+
+*Xinmin Zhang, Qiang He 0001, Hao Fan 0006, Song Wu 0001*
+
+**TL;DR** — Faascale enables runtime vertical memory scaling of Firecracker microVMs for serverless functions, eliminating the need to restart or pre-provision fixed memory sizes.
+
+**Why notable** — Memory over-provisioning is a major cost inefficiency in serverless platforms; Faascale's live memory elasticity directly reduces waste while maintaining the isolation guarantees of microVM-based FaaS.
+
+[→ Read paper](https://doi.org/10.1145/3698038.3698512)
+
+---
+
+### AutoBurst: Autoscaling Burstable Instances for Cost-effective Latency SLOs
+
+*Rubaba Hasan, Timothy Zhu, Bhuvan Urgaonkar*
+
+**TL;DR** — AutoBurst exploits burstable cloud instance types and their CPU credit mechanics to autoscale services at lower cost while still meeting tail-latency SLOs.
+
+**Why notable** — Burstable instances are widely available on all major clouds yet poorly understood for SLO-sensitive workloads; this paper provides a rigorous autoscaling policy that unlocks significant cost savings without sacrificing latency guarantees.
+
+[→ Read paper](https://doi.org/10.1145/3698038.3698530)
+
+---
+
+### Dynamic Idle Resource Leasing To Safely Oversubscribe Capacity At Meta
+
+*Nishant Gupta, Iyswarya Narayanan, Shivam Handa, Sayak Chakraborti *et al.**
+
+**TL;DR** — Meta's production system dynamically lends idle reserved-capacity to opportunistic workloads, recovering stranded compute while ensuring low-latency eviction when owners reclaim resources.
+
+**Why notable** — This industry paper provides rare visibility into hyperscale capacity management at Meta's scale, demonstrating that safe oversubscription can recover tens of percent of otherwise idle datacenter capacity.
+
+[→ Read paper](https://doi.org/10.1145/3698038.3698537)
+
+---
+
+### Forecasting Algorithms for Intelligent Resource Scaling: An Experimental Analysis
+
+*Yanlei Diao, Dominik Horn, Andreas Kipf, Oleksandr Shchur *et al.**
+
+**TL;DR** — A comprehensive empirical study comparing classical and learned forecasting algorithms for cloud autoscaling, yielding concrete guidelines on when each approach wins.
+
+**Why notable** — Autoscaling relies heavily on workload forecasting, yet practitioners lack principled guidance on algorithm choice; this work from the MIT/AWS group fills that gap with rigorous experimentation across real-world cloud traces.
+
+[→ Read paper](https://doi.org/10.1145/3698038.3698564)
+
+---
+
+### Vista: Machine Learning based Database Performance Troubleshooting Framework in Amazon RDS
+
+*Vikramank Y. Singh, Zhao Song 0001, Balakrishnan (Murali) Narayanaswamy, Kapil Eknath Vaidya *et al.**
+
+**TL;DR** — Vista is a production ML framework deployed in Amazon RDS that automatically diagnoses performance regressions by correlating database metrics with causal performance models.
+
+**Why notable** — Database performance debugging at cloud scale is labor-intensive and error-prone; Vista's deployment in RDS demonstrates how ML-driven root-cause analysis can reduce mean-time-to-resolution for thousands of customer instances.
+
+[→ Read paper](https://doi.org/10.1145/3698038.3698519)
+
+---
+
+### Inshrinkerator: Compressing Deep Learning Training Checkpoints via Dynamic Quantization
+
+*Amey Agrawal, Sameer Reddy, Satwik Bhattamishra, Venkata Prabhakara Sarath Nookala *et al.**
+
+**TL;DR** — Inshrinkerator applies dynamic quantization to DL training checkpoints at save time, reducing checkpoint sizes by up to 4x with negligible impact on training convergence.
+
+**Why notable** — Checkpoint storage and I/O are significant costs in large-scale distributed training; this work provides a transparent, easy-to-adopt compression layer that can be retrofitted into existing training pipelines.
+
+[→ Read paper](https://doi.org/10.1145/3698038.3698553)
+
+---
+
+### The Sunk Carbon Fallacy: Rethinking Carbon Footprint Metrics for Effective Carbon-Aware Scheduling
+
+*Noman Bashir, Varun Gohil, Anagha Belavadi Subramanya, Mohammad Shahrad *et al.**
+
+**TL;DR** — The paper argues that conventional carbon metrics misattribute embodied (manufacturing) carbon as a fixed sunk cost, and proposes revised metrics that make carbon-aware scheduling decisions more accurate and actionable.
+
+**Why notable** — Carbon-aware cloud scheduling is an emerging priority, but flawed metrics can lead to counterproductive decisions; this work from the Delimitrou and Irwin groups provides a conceptual correction with broad implications for green cloud policy and tooling.
+
+[→ Read paper](https://doi.org/10.1145/3698038.3698542)
+

site/content/cloud-edge/digests/SoCC-2025/index.md

@@ -0,0 +1,116 @@
+---
+title: SoCC 2025 Digest
+venue: SoCC
+year: 2025
+date: '2025-01-01'
+tags: []
+paper_count: 13
+draft: false
+---
+
+13 papers selected.
+
+---
+
+### From Bottleneck to Breakthrough: Optimizing Scheduling for Hyperscale Containerized Clusters
+
+*Bing Li, Yuquan Ren, Xinyi Song, Zhilei Liu *et al.**
+
+**TL;DR** — Documents production-scale scheduling improvements at a hyperscale cloud provider, demonstrating how targeted optimizations reduce scheduling tail latency and increase cluster utilization in real containerized workloads.
+
+---
+
+### CPU-Limits kill Performance: Time to rethink Resource Control
+
+*Chirag C. Shetty, Sarthak Chakraborty, Hubertus Franke, Larisa Shwartz *et al.**
+
+**TL;DR** — Challenges the conventional use of CPU cgroup limits in cloud environments, showing through production evidence that CFS bandwidth throttling degrades application QoS and proposing a rethink of resource control abstractions.
+
+---
+
+### Rethinking Tiered Memory Management in Cloud Data Centers
+
+*Tong Xing 0002, Jiaxun Yang, Javier Picorel, Antonio Barbalace*
+
+**TL;DR** — Proposes a novel tiered memory management framework for cloud data centers that improves performance by rethinking the placement and migration policies across DRAM and CXL/NVM tiers.
+
+---
+
+### Cost-Efficient Cloud Infrastructure with Hugepage-aware Memory Deduplication
+
+*Ruizhe Huang, Xinyu Wang 0043, Zhida An, Hanwen Lei *et al.**
+
+**TL;DR** — Deploys hugepage-aware memory deduplication in a large production cloud, achieving significant memory savings without the performance regressions that plague conventional THP-based deduplication.
+
+---
+
+### ALAP: Intent-Based Serverless Computing via Delayed Decision-Making
+
+*Prasoon Sinha, Kostis Kaffes, Neeraja J. Yadwadkar*
+
+**TL;DR** — Introduces an intent-based programming model for serverless that defers scheduling decisions until runtime context is available, improving resource efficiency and SLO attainment over eager placement strategies.
+
+---
+
+### Hydra: Virtualized Multi-Language Runtime for High-Density Serverless Platforms
+
+*Serhii Ivanenko, Vasyl Lanko, Rudi Horn, Vojin Jovanovic *et al.**
+
+**TL;DR** — Presents a virtualized runtime that multiplexes multiple language environments within a single sandbox, enabling higher function density and faster cold starts on serverless platforms.
+
+---
+
+### Serverless Elasticsearch: the Architecture Transformation from Stateful to Stateless
+
+*Iraklis Psaroudakis, Pooya Salehi, Jason Bryan, Francisco Fernández Castaño *et al.**
+
+**TL;DR** — Describes Elastic's production migration of Elasticsearch to a serverless, stateless architecture, sharing engineering lessons on decoupling compute from state at cloud scale.
+
+---
+
+### DFUSE: Strongly Consistent Write-Back Kernel Caching for Distributed Userspace File Systems
+
+*Haoyu Li, Jingkai Fu, Qing Li 0002, Windsor Hsu *et al.**
+
+**TL;DR** — Closes a long-standing gap in FUSE-based distributed file systems by enabling strongly consistent write-back caching in the kernel, significantly improving throughput without sacrificing correctness.
+
+---
+
+### Accelerating Distributed Filesystem Metadata Service via Decoupling Directory Semantics from Metadata Indexing
+
+*Wenhao Lv, Hao Guo, Qing Wang 0031, Youyou Lu *et al.**
+
+**TL;DR** — Achieves scalable distributed filesystem metadata by separating directory namespace semantics from the underlying index structure, reducing contention and improving throughput for large-scale cloud storage.
+
+---
+
+### Valet: Efficient Data Placement on Modern SSDs
+
+*Devashish R. Purandare, Peter Alvaro, Avani Wildani, Darrell D. E. Long *et al.**
+
+**TL;DR** — Exploits fine-grained internal SSD geometry to make smarter data placement decisions, yielding measurable I/O performance gains without changes to the host storage stack.
+
+---
+
+### Understanding Diffusion Model Serving in Production: A Top-Down Analysis of Workload, Scheduling, and Resource Efficiency
+
+*Yanying Lin, Shuaipeng Wu, Shutian Luo, Hong Xu 0001 *et al.**
+
+**TL;DR** — Provides the first comprehensive production characterization of diffusion model inference workloads, revealing unique scheduling and resource efficiency challenges distinct from LLM serving.
+
+---
+
+### ModServe: Modality- and Stage-Aware Resource Disaggregation for Scalable Multimodal Model Serving
+
+*Haoran Qiu, Anish Biswas, Zihan Zhao, Jayashree Mohan *et al.**
+
+**TL;DR** — Disaggregates compute resources per modality and pipeline stage for multimodal inference, with a Microsoft production deployment showing improved GPU utilization and latency over monolithic serving.
+
+---
+
+### THORN-ML: Transparent Hardware Offloaded Resilient Networks for RDMA based Distributed ML Workloads
+
+*Maziyar Nazari, Daniel Noland, Giulio Sidoretti, Erika Hunhoff *et al.**
+
+**TL;DR** — Offloads RDMA fault detection and recovery to programmable network hardware, making distributed ML training resilient to network failures without modifying the training framework or incurring software overhead.
+

site/content/cloud-edge/digests/SoCC-2026/index.md

@@ -0,0 +1,13 @@
+---
+title: SoCC 2026 Digest
+venue: SoCC
+year: 2026
+date: '2026-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/TC-2024/index.md

@@ -0,0 +1,132 @@
+---
+title: TC 2024 Digest
+venue: TC
+year: 2024
+date: '2024-01-01'
+tags: []
+paper_count: 12
+draft: false
+---
+
+12 papers selected.
+
+---
+
+### Achieving DRAM-Like PCM by Trading Off Capacity for Latency
+
+*Irina Alam, Puneet Gupta 0001*
+
+**TL;DR** — Proposes a capacity-for-latency trade-off in Phase Change Memory to match DRAM-level access latency without specialized process changes.
+
+**Why notable** — Offers a practical path to deploying PCM as a DRAM alternative, directly addressing the latency gap that has blocked PCM adoption in main-memory systems.
+
+---
+
+### A High-Performance, Energy-Efficient Modular DMA Engine Architecture
+
+*Thomas Benz, Michael Rogenmoser, Paul Scheffler, Samuel Riedel *et al.**
+
+**TL;DR** — Presents a modular, parametric DMA engine design achieving high bandwidth and low energy overhead for heterogeneous SoC data movement.
+
+**Why notable** — Provides an open, well-evaluated DMA baseline that researchers building custom SoCs or accelerators can directly reuse or benchmark against.
+
+---
+
+### Split-Radix Based Compact Hardware Architecture for CRYSTALS-Kyber
+
+*Wenbo Guo 0009, Shuguo Li*
+
+**TL;DR** — Designs a compact FPGA/ASIC hardware accelerator for the CRYSTALS-Kyber post-quantum key encapsulation mechanism using a split-radix NTT.
+
+**Why notable** — Demonstrates efficient hardware realization of a NIST-standardized post-quantum algorithm, critical for transitioning real systems to quantum-resistant cryptography.
+
+---
+
+### Accelerating Sparse DNNs Based on Tiled GEMM
+
+*Cong Guo 0003, Fengchen Xue, Jingwen Leng, Yuxian Qiu *et al.**
+
+**TL;DR** — Accelerates sparse deep neural network inference by restructuring sparse matrix multiplication into tiled GEMM operations that map efficiently onto GPU tensor cores.
+
+**Why notable** — Bridges the gap between theoretical sparsity speedups and GPU hardware realities, achieving practical inference acceleration on commodity hardware.
+
+---
+
+### Xvpfloat: RISC-V ISA Extension for Variable Extended Precision Floating Point Computation
+
+*Eric Guthmuller, César Fuguet, Andrea Bocco, Jérôme Fereyre *et al.**
+
+**TL;DR** — Defines a RISC-V ISA extension supporting variable-precision floating-point operations beyond IEEE 754 standard widths, targeting HPC and scientific computing.
+
+**Why notable** — Addresses precision flexibility at the ISA level, enabling energy-efficient mixed-precision HPC workloads without requiring separate co-processors.
+
+---
+
+### Enabling HW-Based Task Scheduling in Large Multicore Architectures
+
+*Lucas Morais, Carlos Álvarez 0001, Daniel Jiménez-González, Juan Miguel De Haro Ruiz *et al.**
+
+**TL;DR** — Implements task-scheduling logic directly in hardware for large multicore chips, reducing OS scheduling overhead and improving parallelism exploitation.
+
+**Why notable** — Demonstrates that offloading fine-grained task management to hardware can substantially reduce software overhead in many-core systems.
+
+---
+
+### Ara2: Exploring Single- and Multi-Core Vector Processing With an Efficient RVV 1.0 Compliant Open-Source Processor
+
+*Matteo Perotti, Matheus A. Cavalcante, Renzo Andri, Lukas Cavigelli *et al.**
+
+**TL;DR** — Presents Ara2, an open-source RISC-V vector processor fully compliant with RVV 1.0, evaluated across single- and multi-lane configurations for energy-efficient vector workloads.
+
+**Why notable** — Provides the community with a production-quality, open RVV 1.0 reference design and a thorough design-space exploration of vector-processor microarchitecture.
+
+---
+
+### EcoFlow: Efficient Convolutional Dataflows on Low-Power Neural Network Accelerators
+
+*Lois Orosa 0001, Skanda Koppula, Yaman Umuroglu, Konstantinos Kanellopoulos *et al.**
+
+**TL;DR** — Systematically analyzes and optimizes dataflow schedules for convolutional layers on low-power DNN accelerators, yielding significant energy savings.
+
+**Why notable** — Provides a principled framework for dataflow selection that benefits embedded AI accelerator designers targeting energy-constrained deployments.
+
+---
+
+### Prefender: A Prefetching Defender Against Cache Side Channel Attacks as a Pretender
+
+*Luyi Li, Jiayi Huang 0001, Lang Feng 0001, Zhongfeng Wang 0001*
+
+**TL;DR** — Proposes a hardware prefetching mechanism that disguises cache access patterns to defend against conflict-based cache side-channel attacks with low performance overhead.
+
+**Why notable** — Addresses cache side-channel attacks at the microarchitecture level without relying on software mitigations, offering a lightweight and transparent defense.
+
+---
+
+### Randomizing Set-Associative Caches Against Conflict-Based Cache Side-Channel Attacks
+
+*Wei Song 0002, Zihan Xue, Jinchi Han, Zhenzhen Li *et al.**
+
+**TL;DR** — Introduces a cache randomization scheme for set-associative caches that eliminates conflict-based side-channel attack primitives with minimal performance overhead.
+
+**Why notable** — Provides a strong and low-cost architectural defense against a broad class of cache timing attacks that affect nearly all modern processors.
+
+---
+
+### SCARF: Securing Chips With a Robust Framework Against Fabrication-Time Hardware Trojans
+
+*Mohammad Eslami, Tara Ghasempouri, Samuel Pagliarini*
+
+**TL;DR** — Proposes a framework for detecting and mitigating hardware Trojans inserted during chip fabrication using lightweight logic testing combined with side-channel verification.
+
+**Why notable** — Tackles the increasingly critical supply-chain hardware-security threat with a practical methodology applicable during standard chip validation flows.
+
+---
+
+### GraNDe: Efficient Near-Data Processing Architecture for Graph Neural Networks
+
+*Sungmin Yun 0001, Hwayong Nam, Jaehyun Park 0006, Byeongho Kim *et al.**
+
+**TL;DR** — Designs a near-data processing accelerator tailored for graph neural network inference, co-locating compute with graph-structured memory to cut off-chip traffic.
+
+**Why notable** — Demonstrates that memory-wall bottlenecks in GNN inference can be alleviated by a purpose-built PIM design, achieving substantial speedup and energy efficiency gains.
+

site/content/cloud-edge/digests/TC-2025/index.md

@@ -0,0 +1,132 @@
+---
+title: TC 2025 Digest
+venue: TC
+year: 2025
+date: '2025-01-01'
+tags: []
+paper_count: 12
+draft: false
+---
+
+12 papers selected.
+
+---
+
+### RV-CURE: A RISC-V Capability Architecture for Full Memory Safety
+
+*Yonghae Kim, Anurag Kar, Jaewon Lee, Jaekyu Lee *et al.**
+
+**TL;DR** — Extends the RISC-V ISA with hardware capabilities to enforce full memory safety—including bounds checking and pointer provenance—across the entire software stack.
+
+**Why notable** — Demonstrates that capability-based memory safety can be integrated into an open ISA at low cost, with implications for deploying safe-by-default embedded and server systems.
+
+---
+
+### DIVIDE: Efficient RowHammer Defense via In-DRAM Cache-Based Hot Data Isolation
+
+*Haitao Du, Yuxuan Yang 0009, Song Chen 0001, Yi Kang*
+
+**TL;DR** — Proposes an in-DRAM cache that isolates frequently accessed rows, preventing RowHammer hammering without costly refresh storms or off-chip overhead.
+
+**Why notable** — Addresses the escalating RowHammer threat directly inside DRAM with negligible performance overhead, making it a compelling candidate for near-term hardware adoption.
+
+---
+
+### SAL-PIM: A Subarray-Level Processing-in-Memory Architecture With LUT-Based Linear Interpolation for Transformer-Based Text Generation
+
+*Wontak Han, Hyunjun Cho, Donghyuk Kim, Joo-Young Kim 0001*
+
+**TL;DR** — Implements subarray-level PIM with lookup-table interpolation inside DRAM to accelerate the memory-bound non-linear operations of transformer inference.
+
+**Why notable** — Shows how fine-grained PIM design can unblock the bottlenecks specific to LLM inference, providing a pathway to in-memory acceleration of attention and activation layers.
+
+---
+
+### FlashDecoding++Next: High Throughput LLM Inference With Latency and Memory Optimization
+
+*Guohao Dai 0001, Ke Hong, Qiuli Mao, Xiuhong Li *et al.**
+
+**TL;DR** — Extends FlashDecoding with memory and latency optimizations to significantly raise GPU throughput during the autoregressive generation phase of large language models.
+
+**Why notable** — Directly advances the state of the art in LLM serving efficiency on GPU clusters, a problem with immediate commercial relevance.
+
+---
+
+### Mix-GEMM: Extending RISC-V CPUs for Energy-Efficient Mixed-Precision DNN Inference Using Binary Segmentation
+
+*Jordi Fornt, Enrico Reggiani, Pau Fontova-Musté, Narcís Rodas *et al.**
+
+**TL;DR** — Adds lightweight ISA extensions to a RISC-V CPU for mixed-precision inference via binary segmentation, avoiding heavyweight SIMD or dedicated accelerators.
+
+**Why notable** — Provides a cost-effective route to on-device DNN inference on RISC-V embedded cores without the area overhead of a full vector or matrix unit.
+
+---
+
+### Optimizing Tiny Transformers on Low-Power MCUs
+
+*Victor Jean-Baptiste Jung, Alessio Burrello, Moritz Scherer 0001, Francesco Conti 0001 *et al.**
+
+**TL;DR** — Develops an automated deployment pipeline for transformer models on microcontrollers, exploiting tiling, quantization, and kernel fusion to fit within tight memory and compute budgets.
+
+**Why notable** — Enables state-of-the-art sequence models to run on ultra-low-power embedded processors, bridging the gap between transformer research and IoT hardware constraints.
+
+---
+
+### Rethinking Control Flow in Spatial Architectures: Insights Into Control Flow Plane Design
+
+*Jinyi Deng, Xinru Tang, Jiahao Zhang, Yuxuan Li *et al.**
+
+**TL;DR** — Systematically studies control-flow support in dataflow/spatial accelerators and proposes a general control-flow plane abstraction that unifies existing ad hoc designs.
+
+**Why notable** — Offers a principled framework for architects designing the next generation of programmable spatial accelerators, where irregular control flow remains a fundamental challenge.
+
+---
+
+### High-Performance Hardware Implementation of Crystals-Dilithium Based on Improved MDC-NTT
+
+*Yijun Cui, Junjie Zhong, Bei Wang 0013, Tianyu Xu 0002 *et al.**
+
+**TL;DR** — Presents an optimized ASIC accelerator for CRYSTALS-Dilithium digital signatures using an improved multi-delay commutator NTT to maximize throughput.
+
+**Why notable** — Delivers high-performance hardware for a NIST-standardized post-quantum signature scheme, essential for quantum-safe authentication in future systems.
+
+---
+
+### Hardware Accelerated Vision Transformer via Heterogeneous Architecture Design and Adaptive Dataflow Mapping
+
+*Yingxue Gao, Teng Wang, Lei Gong 0003, Chao Wang 0003 *et al.**
+
+**TL;DR** — Designs a heterogeneous accelerator for Vision Transformers that adaptively maps attention and FFN computations onto specialized dataflow engines to maximize utilization.
+
+**Why notable** — Addresses the heterogeneous computational demands of ViT workloads with a flexible architecture, demonstrating state-of-the-art throughput-per-watt on image recognition tasks.
+
+---
+
+### 29-Billion Atoms Molecular Dynamics Simulation With Ab Initio Accuracy on 35 Million Cores of New Sunway Supercomputer
+
+*Xun Wang 0010, Xiangyu Meng 0005, Zhuoqiang Guo, Mingzhen Li 0001 *et al.**
+
+**TL;DR** — Scales a machine-learning-based molecular dynamics simulation to 29 billion atoms at ab-initio accuracy across 35 million cores on the Sunway supercomputer.
+
+**Why notable** — Sets a landmark in scientific HPC scalability, demonstrating how deep co-design of architecture, communication, and ML models enables quantum-accurate simulation at unprecedented scale.
+
+---
+
+### AXI-REALM: Safe, Modular and Lightweight Traffic Monitoring and Regulation for Heterogeneous Mixed-Criticality Systems
+
+*Thomas Benz, Alessandro Ottaviano, Chaoqun Liang, Robert Balas *et al.**
+
+**TL;DR** — Introduces an open-source AXI interconnect module that enforces bandwidth and latency isolation between mixed-criticality components in heterogeneous SoCs.
+
+**Why notable** — Provides a practical, standards-compliant hardware mechanism for achieving real-time guarantees in safety-critical SoCs built from commodity IP blocks.
+
+---
+
+### Stream: Design Space Exploration of Layer-Fused DNNs on Heterogeneous Dataflow Accelerators
+
+*Arne Symons, Linyan Mei, Steven Colleman, Pouya Houshmand *et al.**
+
+**TL;DR** — Presents a framework for exploring the design space of layer-fused DNN execution across heterogeneous arrays, jointly optimizing tiling, scheduling, and memory allocation.
+
+**Why notable** — Enables systematic co-design of DNN models and heterogeneous accelerators, a key capability as networks grow more complex and hardware resources more diverse.
+

site/content/cloud-edge/digests/TC-2026/index.md

@@ -0,0 +1,13 @@
+---
+title: TC 2026 Digest
+venue: TC
+year: 2026
+date: '2026-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/TCC-2024/index.md

@@ -0,0 +1,132 @@
+---
+title: TCC 2024 Digest
+venue: TCC
+year: 2024
+date: '2024-01-01'
+tags: []
+paper_count: 12
+draft: false
+---
+
+12 papers selected.
+
+---
+
+### FaaSCtrl: A Comprehensive-Latency Controller for Serverless Platforms
+
+*Abhisek Panda, Smruti R. Sarangi*
+
+**TL;DR** — FaaSCtrl is a feedback-control system for serverless platforms that jointly manages cold-start, queuing, and execution latency to meet end-to-end SLOs.
+
+**Why notable** — One of the few serverless controllers that addresses all three latency components together, providing a principled alternative to ad-hoc autoscaling heuristics.
+
+---
+
+### FUSIONIZE++: Improving Serverless Application Performance Using Dynamic Task Inlining and Infrastructure Optimization
+
+*Trever Schirmer, Joel Scheuner, Tobias Pfandzelter, David Bermbach*
+
+**TL;DR** — FUSIONIZE++ dynamically fuses serverless functions at runtime and co-optimizes infrastructure selection to cut invocation overhead and cost.
+
+**Why notable** — Demonstrates concrete end-to-end performance gains from function fusion in real serverless deployments, directly relevant to practitioners optimizing FaaS pipelines.
+
+---
+
+### BaaSLess: Backend-as-a-Service (BaaS)-Enabled Workflows in Federated Serverless Infrastructures
+
+*Thomas Larcher, Philipp Gritsch, Stefan Nastic, Sashko Ristov*
+
+**TL;DR** — BaaSLess integrates BaaS capabilities into serverless workflow execution across federated multi-provider infrastructures, enabling stateful cross-cloud function orchestration.
+
+**Why notable** — Addresses the underexplored intersection of BaaS, serverless, and federation, offering a practical blueprint for multi-cloud serverless applications.
+
+---
+
+### Slim and Fast: Low-Overhead Container Overlay Network With Fast Connection Setup
+
+*Fusheng Lin, Xin Zhang 0117, Guo Chen 0001, Li Chen 0008 *et al.**
+
+**TL;DR** — A redesigned container overlay network that minimizes control-plane overhead and dramatically reduces connection setup latency for microservice-dense deployments.
+
+**Why notable** — The implementation targets real Kubernetes environments and directly improves east-west latency for microservices at scale.
+
+---
+
+### Trustless Collaborative Cloud Federation
+
+*Bishakh Chandra Ghosh, Sandip Chakraborty 0001*
+
+**TL;DR** — A blockchain-backed protocol that enables resource sharing across competing cloud providers without requiring a trusted third party.
+
+**Why notable** — Tackles the fundamental trust barrier in multi-cloud federation with a practical, decentralized design that avoids provider lock-in.
+
+---
+
+### An Adaptive Cloud Resource Quota Scheme Based on Dynamic Portraits and Task-Resource Matching
+
+*Zuodong Jin, Dan Tao, Peng Qi 0006, Ruipeng Gao*
+
+**TL;DR** — Builds dynamic workload portraits per tenant and matches them to resource quotas in real time, improving utilization while respecting SLAs in IaaS/PaaS clouds.
+
+**Why notable** — Moves beyond static quota assignment with a data-driven approach validated on production cloud workload traces.
+
+---
+
+### Aggregate Monitoring for Geo-Distributed Kubernetes Cluster Federations
+
+*Chih-Kai Huang 0001, Guillaume Pierre*
+
+**TL;DR** — Proposes a scalable monitoring architecture for Kubernetes federations that aggregates metrics across geo-distributed clusters with low overhead.
+
+**Why notable** — Practical multi-cloud observability is rarely addressed at the federation layer; this work provides a deployable solution with measured performance on real clusters.
+
+---
+
+### Root Cause Analysis for Cloud-Native Applications
+
+*Bartosz Zurkowski, Krzysztof Zielinski*
+
+**TL;DR** — A graph-based RCA framework for microservice architectures that correlates traces, metrics, and logs to pinpoint fault origins in cloud-native deployments.
+
+**Why notable** — Directly applicable to production microservice operations, offering automated diagnosis that reduces mean time to recovery in complex service graphs.
+
+---
+
+### RAM: A Resource-Aware DDoS Attack Mitigation Framework in Clouds
+
+*Fangyuan Xing, Fei Tong 0001, Jialong Yang, Guang Cheng 0001 *et al.**
+
+**TL;DR** — RAM dynamically allocates cloud resources for DDoS mitigation based on attack intensity, balancing protection effectiveness against resource cost.
+
+**Why notable** — Combines attack detection and elastic resource provisioning in a single framework, making it immediately relevant for cloud security operations.
+
+---
+
+### Enabling Multi-Layer Threat Analysis in Dynamic Cloud Environments
+
+*Salman Manzoor, Antonios Gouglidis, Matthew Bradbury, Neeraj Suri*
+
+**TL;DR** — A multi-layer threat analysis system that correlates security events across IaaS, PaaS, and application layers to detect composite attacks in dynamic cloud deployments.
+
+**Why notable** — Addresses the gap between per-layer security tools and cross-layer attack detection, which is critical for securing modern cloud stacks.
+
+---
+
+### Hyperion: Hardware-Based High-Performance and Secure System for Container Networks
+
+*Myoungsung You, Minjae Seo, Jaehan Kim, Seungwon Shin 0001 *et al.**
+
+**TL;DR** — Hyperion offloads container network security enforcement to programmable hardware, achieving line-rate packet processing with strong isolation guarantees.
+
+**Why notable** — Shows that hardware offload can simultaneously improve both throughput and security in container networking, with real implementation results.
+
+---
+
+### D-STACK: High Throughput DNN Inference by Effective Multiplexing and Spatio-Temporal Scheduling of GPUs
+
+*Aditya Dhakal, Sameer G. Kulkarni, K. K. Ramakrishnan*
+
+**TL;DR** — D-STACK multiplexes multiple DNN inference jobs on shared GPUs via spatio-temporal scheduling, significantly increasing throughput without latency SLO violations.
+
+**Why notable** — Addresses a critical cloud resource management challenge for AI inference services, with a real system implementation and evaluation against production workloads.
+

site/content/cloud-edge/digests/TCC-2025/index.md

@@ -0,0 +1,132 @@
+---
+title: TCC 2025 Digest
+venue: TCC
+year: 2025
+date: '2025-01-01'
+tags: []
+paper_count: 12
+draft: false
+---
+
+12 papers selected.
+
+---
+
+### DRKC: Deep Reinforcement Learning Enhanced Microservice Scheduling on Kubernetes Clusters in Cloud-Edge Environment
+
+*Jian Jiang, Qianmu Li, Pengchuan Wang, Yunhuai Liu*
+
+**TL;DR** — DRKC uses deep reinforcement learning to schedule microservices across Kubernetes clusters spanning cloud and edge nodes, optimizing latency and resource utilization.
+
+**Why notable** — One of the few papers to tackle DRL-based microservice placement at the Kubernetes level in a real cloud-edge topology, making it directly actionable for practitioners.
+
+---
+
+### DesFaaS: Cross-Layer Joint Dynamic Deployment System for Serverless Stateful Functions
+
+*Yuquan Jing, Binbin Feng, Zhijun Ding*
+
+**TL;DR** — DesFaaS jointly optimizes the placement and lifecycle of stateful serverless functions across compute, network, and storage layers to reduce latency and cost.
+
+**Why notable** — Addresses the hard problem of state management in FaaS by co-designing across layers, opening a new direction for stateful serverless architectures.
+
+---
+
+### CARL: Cost-Optimized Online Container Placement on VMs Using Adversarial Reinforcement Learning
+
+*Prathamesh Saraf Vinayak, Saswat Subhajyoti Mallick, Lakshmi Jagarlamudi, Anirban Chakraborty 0001 *et al.**
+
+**TL;DR** — CARL applies adversarial reinforcement learning to online container bin-packing on cloud VMs, minimizing cost while handling adversarial workload patterns.
+
+**Why notable** — The adversarial training objective makes the scheduler robust to worst-case workload shifts, a significant advance over standard RL-based placement.
+
+---
+
+### CADER: Cost-Efficient Cloud Application Deployment With Tenant Requirement Guarantee in Multi-Clouds
+
+*Huaqing Tu, Ziqiang Hua, Qianpiao Ma, Hanguang Luo *et al.**
+
+**TL;DR** — CADER places cloud application components across multiple providers to minimize cost while enforcing per-tenant SLA and data-locality constraints.
+
+**Why notable** — Provides a rigorous multi-cloud placement framework that balances cost and tenant requirements, directly addressing a key challenge in multi-cloud SaaS/PaaS deployments.
+
+---
+
+### Cloud Load Balancers Need to Stay Off the Data Path
+
+*Yuchen Zhang, Shuai Jin, Zhenyu Wen, Shibo He *et al.**
+
+**TL;DR** — Based on large-scale production experience, this paper argues and demonstrates that cloud load balancers should operate out-of-band to eliminate throughput bottlenecks at scale.
+
+**Why notable** — A rare production-grounded architectural insight from a major cloud provider that challenges conventional in-path load balancer designs.
+
+---
+
+### PHOENIX: Misconfiguration Detection for AWS Serverless Computing
+
+*Jinfeng Wen, Haodi Ping*
+
+**TL;DR** — PHOENIX automatically detects security and correctness misconfigurations in AWS Lambda deployments by analyzing IAM policies, triggers, and function configurations.
+
+**Why notable** — Serverless misconfiguration is a leading cause of cloud security incidents; PHOENIX provides an automated, deployable detection tool for AWS environments.
+
+---
+
+### FaaSScout: Fast and Full Lifecycle RCA for FaaS Applications Using Salient Feature Mining
+
+*Min Li 0065, Jin Huang, Pengfei Chen 0002, Chongkang Tan*
+
+**TL;DR** — FaaSScout performs root cause analysis across the full FaaS invocation lifecycle by mining salient features from traces and logs to localize faults quickly.
+
+**Why notable** — Fills a critical operational gap for serverless: fast, automated fault diagnosis that covers cold starts, platform issues, and application errors in a unified framework.
+
+---
+
+### Hybrid Serverless Platform for Smart Deployment of Service Function Chains
+
+*Sheshadri K. R, J. Lakshmi*
+
+**TL;DR** — A hybrid serverless platform that intelligently places NFV service function chains on serverless infrastructure, reducing provisioning overhead while meeting latency targets.
+
+**Why notable** — Bridges serverless computing and NFV, demonstrating that serverless abstractions can be applied to network function deployment with competitive performance.
+
+---
+
+### PiCoP: Service Mesh for Sharing Microservices in Multiple Environments Using Protocol-Independent Context Propagation
+
+*Hiroya Onoe, Daisuke Kotani, Yasuo Okabe*
+
+**TL;DR** — PiCoP extends service mesh capabilities to span heterogeneous protocol environments by providing protocol-independent context propagation for distributed microservice tracing and control.
+
+**Why notable** — Solves a practical multi-cloud and hybrid deployment challenge where microservices communicate over different protocols, enabling unified observability and policy enforcement.
+
+---
+
+### A Reference Architecture for Governance of Cloud Native Applications
+
+*William Pourmajidi, Lei Zhang 0078, John Steinbacher, Tony Erwin *et al.**
+
+**TL;DR** — Proposes and validates a reference architecture that unifies policy enforcement, compliance, and lifecycle governance for cloud-native applications across deployment environments.
+
+**Why notable** — Provides a vendor-neutral governance blueprint grounded in industry practice, filling a gap between DevOps tooling and organizational cloud compliance requirements.
+
+---
+
+### Observability and Incident Response in Managed Serverless Environments Using Ontology-Based Log Monitoring
+
+*Lavi Ben-Shimol, Edita Grolman, Aviad Elyashar, Inbar Maimon *et al.**
+
+**TL;DR** — Uses an ontology-based approach to monitor serverless function logs, enabling structured incident detection and response in managed FaaS environments.
+
+**Why notable** — Brings structured knowledge representation to serverless observability, enabling richer incident correlation than rule-based or purely ML-based log monitors.
+
+---
+
+### A Run-Time Framework for Ensuring Zero-Trust State of Client's Machines in Cloud Environment
+
+*Devki Nandan Jha, Graham Lenton, James Asker, David Blundell *et al.**
+
+**TL;DR** — A runtime attestation framework continuously verifies the security posture of client machines accessing cloud resources, enforcing zero-trust policies based on live system state.
+
+**Why notable** — Moves zero-trust enforcement from static policy configuration to continuous runtime verification, addressing a key gap in current cloud access control models.
+

site/content/cloud-edge/digests/TCC-2026/index.md

@@ -0,0 +1,13 @@
+---
+title: TCC 2026 Digest
+venue: TCC
+year: 2026
+date: '2026-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/TOCS-2024/index.md

@@ -0,0 +1,92 @@
+---
+title: TOCS 2024 Digest
+venue: TOCS
+year: 2024
+date: '2024-01-01'
+tags: []
+paper_count: 8
+draft: false
+---
+
+8 papers selected.
+
+---
+
+### PMAlloc: A Holistic Approach to Improving Persistent Memory Allocation
+
+*Zheng Dang, Shuibing He, Xuechen Zhang, Peiyi Hong *et al.**
+
+**TL;DR** — PMAlloc redesigns persistent memory allocation end-to-end, co-optimizing the allocator's data structures, concurrency, and crash consistency to dramatically reduce allocation overhead.
+
+**Why notable** — Persistent memory is still poorly understood at the allocator level; this paper offers a rare holistic treatment that will inform future PM software stacks.
+
+---
+
+### Boki: Towards Data Consistency and Fault Tolerance with Shared Logs in Stateful Serverless Computing
+
+*Zhipeng Jia, Emmett Witchel*
+
+**TL;DR** — Boki introduces a shared-log abstraction for serverless functions that provides strong consistency and fault tolerance without requiring developers to manage state explicitly.
+
+**Why notable** — It reframes stateful serverless as a log-centric problem, offering a clean systems primitive that substantially simplifies correctness guarantees in function-as-a-service platforms.
+
+---
+
+### Diciclo: Flexible User-level Services for Efficient Multitenant Isolation
+
+*Giorgos Kappes, Stergios V. Anastasiadis*
+
+**TL;DR** — Diciclo provides a user-level framework that lets services customize their isolation mechanisms without kernel modifications, reducing interference among co-located tenants.
+
+**Why notable** — Multitenant isolation in cloud systems is typically a blunt instrument; this work shows that flexible, low-overhead isolation can be achieved entirely in user space.
+
+---
+
+### SPATA: Effective OS Bug Detection with Summary-Based, Alias-Aware, and Path-Sensitive Typestate Analysis
+
+*Tuo Li, Jia-Ju Bai, Yulei Sui, Shi-Min Hu*
+
+**TL;DR** — SPATA applies a summary-based, alias-aware, and path-sensitive typestate analysis to detect resource-management bugs in OS kernels at scale.
+
+**Why notable** — Finding use-after-free and double-free bugs in OS code remains an open challenge; SPATA's precision improvements over prior static analyses make it a practical tool for kernel hardening.
+
+---
+
+### Trinity: High-Performance and Reliable Mobile Emulation through Graphics Projection
+
+*Hao Lin, Zhenhua Li, Di Gao, Yunhao Liu *et al.**
+
+**TL;DR** — Trinity projects GPU rendering workloads from a mobile device onto a remote high-performance GPU, enabling faithful, high-throughput mobile emulation.
+
+**Why notable** — Mobile app testing at scale requires accurate emulation of GPU behavior; Trinity's graphics-projection design closes a long-standing fidelity gap in mobile emulators.
+
+---
+
+### Optimizing Resource Management for Shared Microservices: A Scalable System Design
+
+*Shutian Luo, Chenyu Lin, Kejiang Ye, Guoyao Xu *et al.**
+
+**TL;DR** — This paper presents a scalable resource-management system for shared microservices that reduces interference and improves utilization in large-scale production deployments.
+
+**Why notable** — Microservice co-location is the norm in modern clouds, yet managing their shared resources at scale remains unsolved; this work delivers practical, production-validated answers.
+
+---
+
+### Hardware-Software Collaborative Tiered-Memory Management Framework for Virtualization
+
+*Sai Sha, Chuandong Li, Xiaolin Wang, Zhenlin Wang *et al.**
+
+**TL;DR** — A hardware-software co-design framework that transparently manages hot/cold data placement across DRAM and slower memory tiers inside virtual machines.
+
+**Why notable** — As CXL-attached and NVM memory tiers become mainstream in data centers, principled tiered-memory management in hypervisors becomes critical; this paper provides a solid baseline.
+
+---
+
+### Component-distinguishable Co-location and Resource Reclamation for High-throughput Computing
+
+*Laiping Zhao, Yushuai Cui, Yanan Yang, Xiaobo Zhou *et al.**
+
+**TL;DR** — This system differentiates micro-components of co-located workloads to reclaim idle resources precisely, boosting overall cluster throughput without violating SLOs.
+
+**Why notable** — Coarse-grained co-location wastes significant cluster capacity; the component-level granularity introduced here sets a new standard for resource-reclamation systems.
+

site/content/cloud-edge/digests/TOCS-2025/index.md

@@ -0,0 +1,112 @@
+---
+title: TOCS 2025 Digest
+venue: TOCS
+year: 2025
+date: '2025-01-01'
+tags: []
+paper_count: 10
+draft: false
+---
+
+10 papers selected.
+
+---
+
+### Whole-system Persistence Made Efficient with Tree-structured Checkpointing on Microkernel
+
+*Mingkai Dong, Fangnuo Wu, Gequan Mo, Haibo Chen*
+
+**TL;DR** — A microkernel-based whole-system persistence scheme uses tree-structured incremental checkpointing to achieve low-overhead, crash-consistent snapshots of the entire OS state.
+
+**Why notable** — Whole-system persistence is a foundational building block for reliable systems; this paper shows it can be done efficiently within a microkernel architecture.
+
+---
+
+### XpuTEE: A High-Performance and Practical Heterogeneous Trusted Execution Environment for GPUs
+
+*Shulin Fan, Zhichao Hua, Yubin Xia, Haibo Chen*
+
+**TL;DR** — XpuTEE extends trusted execution environments to GPUs by designing a hardware-assisted isolation mechanism that protects GPU computations with low performance overhead.
+
+**Why notable** — As GPUs process sensitive ML workloads in shared clouds, TEE support for accelerators is urgently needed; XpuTEE is a comprehensive and practical solution.
+
+---
+
+### RegVault II: Achieving Hardware-Assisted Selective Kernel Data Randomization for Multiple Architectures
+
+*Ruorong Guo, Yangye Zhou, Jinyan Xu, Wenbo Shen *et al.**
+
+**TL;DR** — RegVault II uses hardware features to selectively randomize sensitive kernel data structures at runtime across multiple ISAs, raising the bar for kernel exploitation.
+
+**Why notable** — Kernel data-only attacks bypass existing code-randomization defenses; this work's multi-architecture approach makes selective data randomization practical for production kernels.
+
+---
+
+### Validating JIT Compilers via Compilation Space Exploration
+
+*Cong Li, Yanyan Jiang, Chang Xu, Zhendong Su*
+
+**TL;DR** — Compilation space exploration systematically generates and tests the large space of valid JIT compilation outcomes to find miscompilation bugs in production JIT compilers.
+
+**Why notable** — JIT correctness is notoriously hard to test; this paper's systematic exploration strategy finds real bugs in widely-used runtimes and advances the state of compiler validation.
+
+---
+
+### Freezing-based Memory and Process Co-design for User Experience on Resource-limited Mobile Devices
+
+*Changlong Li, Zongwei Zhu, Chun Jason Xue, Yu Liang *et al.**
+
+**TL;DR** — A co-designed memory and process management scheme freezes background processes at fine granularity to reclaim memory while preserving fast resume latency on constrained mobile hardware.
+
+**Why notable** — Mobile memory pressure directly degrades user experience; this paper's co-design perspective yields measurable improvements on real devices with limited resources.
+
+---
+
+### Analyzing Configuration Dependencies of File Systems
+
+*Tabassum Mahmud, Om Rameshwar Gatla, Duo Zhang, Carson Love *et al.**
+
+**TL;DR** — This work systematically analyzes the dependency graph among file-system configuration options to reveal hidden interactions that lead to silent data corruption or crashes.
+
+**Why notable** — File-system misconfiguration is a major source of data loss in practice; understanding configuration dependencies is essential for building safer storage systems.
+
+---
+
+### Efficient Fault Tolerance for Stateful Serverless Computing with Asymmetric Logging
+
+*Sheng Qi, Haoyu Feng, Xuanzhe Liu, Xin Jin*
+
+**TL;DR** — Asymmetric logging decouples the logging cost between the fast and slow paths of stateful serverless functions, enabling low-overhead fault tolerance without sacrificing recovery guarantees.
+
+**Why notable** — Fault tolerance for stateful serverless remains an open performance challenge; this paper's asymmetric design significantly reduces logging overhead compared to symmetric approaches.
+
+---
+
+### Towards Serialization/Deserialization-free State Transfer in Serverless Workflows
+
+*Xingda Wei, Fangming Lu, Zhuobin Huang, Rong Chen *et al.**
+
+**TL;DR** — This system eliminates serialization and deserialization costs when passing state between serverless functions by enabling direct in-memory state transfer across workflow stages.
+
+**Why notable** — Ser/deser overhead is a dominant cost in serverless workflows; removing it fundamentally changes the performance profile of function chaining at scale.
+
+---
+
+### Enabling Anonymous Online Streaming Analytics at the Network Edge
+
+*Yunming Xiao, Yanqi Gu, Yibo Zhao, Sen Lin *et al.**
+
+**TL;DR** — This paper designs an edge-based streaming analytics framework that enforces differential privacy while processing high-throughput data streams with low latency.
+
+**Why notable** — Privacy-preserving analytics at the edge is increasingly required by regulation and user expectation; this system shows it can be done at practical streaming throughputs.
+
+---
+
+### LCL+: a Lock Chain Length-based Distributed Deadlock Detection and Resolution Service Built for OceanBase
+
+*Zhenkun Yang, Chen Qian, Xuwang Teng, Fanyu Kong *et al.**
+
+**TL;DR** — LCL+ detects and resolves distributed deadlocks in the OceanBase database by tracking lock-chain lengths across nodes, achieving low overhead with fast detection latency.
+
+**Why notable** — Deadlock detection in large-scale distributed databases is an unsolved production problem; this paper presents a battle-tested algorithm deployed in a major commercial system.
+

site/content/cloud-edge/digests/TOCS-2026/index.md

@@ -0,0 +1,13 @@
+---
+title: TOCS 2026 Digest
+venue: TOCS
+year: 2026
+date: '2026-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/TPDS-2024/index.md

@@ -0,0 +1,132 @@
+---
+title: TPDS 2024 Digest
+venue: TPDS
+year: 2024
+date: '2024-01-01'
+tags: []
+paper_count: 12
+draft: false
+---
+
+12 papers selected.
+
+---
+
+### Runtime Performance Anomaly Diagnosis in Production HPC Systems Using Active Learning
+
+*Burak Aksar, Efe Sencan, Benjamin Schwaller, Omar Aaziz *et al.**
+
+**TL;DR** — An active-learning framework automatically diagnoses runtime performance anomalies in production HPC systems by querying targeted job profiles to minimize labeling effort.
+
+**Why notable** — It bridges ML-based anomaly detection and operational HPC monitoring, demonstrating scalable root-cause identification on real supercomputer workloads.
+
+---
+
+### AutoDDL: Automatic Distributed Deep Learning With Near-Optimal Bandwidth Cost
+
+*Jinfan Chen, Shigang Li 0002, Ran Guo, Jinhui Yuan *et al.**
+
+**TL;DR** — AutoDDL automatically searches for the distributed DNN training strategy that minimizes communication bandwidth cost while meeting performance targets.
+
+**Why notable** — Combining Hoefler's communication-model expertise with automatic strategy search, this paper is essential reading for practitioners scaling DNN training across large clusters.
+
+---
+
+### PeakFS: An Ultra-High Performance Parallel File System via Computing-Network-Storage Co-Optimization for HPC Applications
+
+*Yixiao Chen, Haomai Yang, Kai Lu 0002, Wenlve Huang *et al.**
+
+**TL;DR** — PeakFS co-optimizes compute, network, and storage layers of a parallel file system to deliver ultra-high I/O throughput for HPC workloads.
+
+**Why notable** — Its holistic co-design perspective sets a new performance baseline for HPC storage and provides actionable insights for next-generation parallel file system architects.
+
+---
+
+### Formal Definitions and Performance Comparison of Consistency Models for Parallel File Systems
+
+*Chen Wang 0004, Kathryn M. Mohror, Marc Snir*
+
+**TL;DR** — This paper formalizes consistency models used by parallel file systems and provides the first systematic empirical comparison of their performance trade-offs.
+
+**Why notable** — Rigorous formal treatment from Snir and Mohror clarifies long-standing ambiguities in HPC storage semantics, making it an important reference for storage system designers.
+
+---
+
+### Malleability in Modern HPC Systems: Current Experiences, Challenges, and Future Opportunities
+
+*Ahmad Tarraf, Martin Schreiber 0001, Alberto Cascajo, Jean-Baptiste Besnard *et al.**
+
+**TL;DR** — A comprehensive survey of dynamic resource malleability in HPC, covering runtime systems, job schedulers, and application-level support with lessons from production systems.
+
+**Why notable** — As energy-aware and burst-resilient HPC scheduling becomes critical, this broad community-driven survey is the definitive starting point for research on malleable HPC runtimes.
+
+---
+
+### Pyxis: Scheduling Mixed Tasks in Disaggregated Datacenters
+
+*Sheng Qi, Chao Jin, Mosharaf Chowdhury, Zhenming Liu *et al.**
+
+**TL;DR** — Pyxis is a scheduler for disaggregated datacenters that jointly manages latency-sensitive and batch tasks by exploiting flexible resource pooling across the disaggregated fabric.
+
+**Why notable** — It tackles one of the central open problems in cloud scheduling—multi-tenancy under disaggregation—with rigorous analysis and demonstrated gains on real workloads.
+
+---
+
+### Swift: Expedited Failure Recovery for Large-Scale DNN Training
+
+*Yuchen Zhong, Guangming Sheng, Juncheng Liu, Jinhui Yuan *et al.**
+
+**TL;DR** — Swift dramatically reduces checkpoint and recovery overhead for large-scale DNN training by combining lightweight in-memory snapshots with selective recomputation.
+
+**Why notable** — As training runs on hundreds of GPUs grow longer and failures become inevitable, Swift's fault-tolerance approach directly addresses a practical bottleneck in modern deep-learning infrastructure.
+
+---
+
+### FastLoad: Speeding Up Data Loading of Both Sparse Matrix and Vector for SpMV on GPUs
+
+*Jinyu Hu, Huizhang Luo, Hong Jiang 0001, Guoqing Xiao 0001 *et al.**
+
+**TL;DR** — FastLoad optimizes the memory-access pattern for loading both the sparse matrix and the dense vector in SpMV on GPUs, yielding significant throughput improvements.
+
+**Why notable** — SpMV is a foundational kernel for scientific computing and graph analytics; this paper's memory-access analysis and optimizations benefit a wide class of GPU applications.
+
+---
+
+### KLNK: Expanding Page Boundaries in a Distributed Shared Memory System
+
+*Yiwei Ci, Michael R. Lyu, Zhan Zhang 0002, De-Cheng Zuo *et al.**
+
+**TL;DR** — KLNK extends distributed shared memory page granularity to reduce false sharing and improve throughput for irregular access patterns.
+
+**Why notable** — It addresses a classic but unsolved bottleneck in DSM systems with a practical, page-table-level mechanism applicable to emerging disaggregated memory architectures.
+
+---
+
+### Enabling Efficient Erasure Coding in Disaggregated Memory Systems
+
+*Qiliang Li, Liangliang Xu, Yongkun Li 0001, Min Lyu *et al.**
+
+**TL;DR** — This paper designs an erasure-coding scheme tailored to disaggregated memory, exploiting its unique bandwidth topology to achieve fault tolerance with low overhead.
+
+**Why notable** — Fault tolerance in disaggregated memory is an open problem of growing importance; this work provides concrete mechanisms and strong performance results.
+
+---
+
+### Simple, Fast and Widely Applicable Concurrent Memory Reclamation via Neutralization
+
+*Ajay Singh 0002, Trevor Alexander Brown, Ali José Mashtizadeh*
+
+**TL;DR** — Neutralization is a new mechanism for safe memory reclamation in lock-free data structures that is simpler, faster, and more portable than prior approaches.
+
+**Why notable** — Safe memory reclamation is a pervasive challenge in concurrent programming; this algorithm's breadth of applicability and performance improvements make it highly reusable.
+
+---
+
+### DeepTM: Efficient Tensor Management in Heterogeneous Memory for DNN Training
+
+*Haoran Zhou, Wei Rang, Hongyang Chen 0001, Xiaobo Zhou 0002 *et al.**
+
+**TL;DR** — DeepTM dynamically manages tensor placement across DRAM and NVM during DNN training to reduce memory pressure and improve throughput.
+
+**Why notable** — As model sizes outpace GPU memory, heterogeneous memory management becomes critical; DeepTM provides a practical, training-aware solution with measurable benefits.
+

site/content/cloud-edge/digests/TPDS-2025/index.md

@@ -0,0 +1,132 @@
+---
+title: TPDS 2025 Digest
+venue: TPDS
+year: 2025
+date: '2025-01-01'
+tags: []
+paper_count: 12
+draft: false
+---
+
+12 papers selected.
+
+---
+
+### HARMONIC: Uncertainty-Aware Multi-Objective Optimization for Energy-Efficient HPC Resource Management
+
+*Kyrian Adimora, Hongyang Sun 0001*
+
+**TL;DR** — HARMONIC applies uncertainty-aware multi-objective optimization to jointly minimize energy consumption and maximize performance for HPC resource allocation.
+
+**Why notable** — It directly addresses the growing demand for energy-proportional HPC scheduling with principled probabilistic models, making it relevant to both system designers and green-computing researchers.
+
+---
+
+### MIST: Towards MPI Instant Startup and Termination on Tianhe HPC Systems
+
+*Yiqin Dai, Ruibo Wang, Yong Dong, Min Xie *et al.**
+
+**TL;DR** — MIST reduces MPI job startup and termination latency to near-instant on the Tianhe supercomputer by redesigning the process-management and communication-bootstrap path.
+
+**Why notable** — Startup overhead is a significant fraction of short-job turnaround time at scale; MIST's results on a top-ranked system provide a concrete reference for HPC runtime developers.
+
+---
+
+### Scheduling With Lightweight Predictions in Power-Constrained HPC Platforms
+
+*Danilo Carastan-Santos, Georges Da Costa, Igor Fontana De Nardin, Millian Poquet *et al.**
+
+**TL;DR** — This paper develops a scheduling framework that uses lightweight runtime predictions to respect power caps on HPC systems while minimizing job slowdown.
+
+**Why notable** — Power capping is now a first-class constraint on modern supercomputers, and this work from leading European HPC scheduling researchers offers practical, deployable algorithms.
+
+---
+
+### PipeMesh: Achieving Memory-Efficient Computation-Communication Overlap for Training Large Language Models
+
+*Fanxin Li, Shixiong Zhao, Yuhao Qing, Jianyu Jiang *et al.**
+
+**TL;DR** — PipeMesh overlaps pipeline-parallel computation and communication for LLM training while carefully managing memory to avoid out-of-memory failures.
+
+**Why notable** — Communication-computation overlap is one of the most impactful levers for LLM training efficiency, and PipeMesh's memory-awareness addresses the key practical constraint.
+
+---
+
+### EfficientMoE: Optimizing Mixture-of-Experts Model Training With Adaptive Load Balance
+
+*Yan Zeng, Chengchuang Huang, Yipeng Mei, Lifu Zhang 0004 *et al.**
+
+**TL;DR** — EfficientMoE introduces an adaptive load-balancing strategy for Mixture-of-Experts training that equalizes expert utilization and reduces communication bottlenecks.
+
+**Why notable** — MoE models are central to frontier LLM architectures, and load imbalance is their primary training inefficiency; this work provides both analysis and a practical solution.
+
+---
+
+### SSpMM: Efficiently Scalable SpMM Kernels Across Multiple Generations of Tensor Cores
+
+*Zeyu Xue, Mei Wen, Jianchao Yang, Minjin Tang *et al.**
+
+**TL;DR** — SSpMM delivers portable, high-performance sparse-matrix dense-matrix multiplication kernels that scale efficiently across Ampere, Hopper, and future Tensor Core generations.
+
+**Why notable** — SpMM is a bottleneck in GNN training and scientific computing; cross-generation portability without performance loss is a significant contribution for the GPU computing community.
+
+---
+
+### IceFrog: A Layer-Elastic Scheduling System for Deep Learning Training in GPU Clusters
+
+*Wei Gao 0064, Zhuoyuan Ouyang, Peng Sun 0006, Tianwei Zhang 0004 *et al.**
+
+**TL;DR** — IceFrog dynamically adjusts the number of pipeline stages (layers) assigned to each GPU during training to adapt to cluster heterogeneity and improve utilization.
+
+**Why notable** — Layer elasticity is a novel dimension of flexibility in distributed DNN training; IceFrog's scheduler provides measurable throughput gains in realistic heterogeneous GPU clusters.
+
+---
+
+### Elastic Relaxation of Concurrent Data Structures
+
+*Kåre von Geijer, Philippas Tsigas*
+
+**TL;DR** — This paper introduces a formal framework and concrete algorithms for elastic relaxation of concurrent data structures, allowing tunable trade-offs between consistency and throughput.
+
+**Why notable** — Tsigas's group advances concurrent data-structure theory with a unifying formalism that subsumes many ad-hoc relaxed designs and enables provable guarantees.
+
+---
+
+### Approximation Algorithms for Scheduling With/Without Deadline Constraints Where Rejection Costs are Proportional to Processing Times
+
+*Olivier Beaumont, Rémi Bouzel, Lionel Eyraud-Dubois, Esragul Korkmaz *et al.**
+
+**TL;DR** — This paper derives new approximation algorithms with tight ratios for online and offline scheduling problems where rejected jobs incur costs proportional to their processing times.
+
+**Why notable** — The theoretical results close open gaps in parallel scheduling complexity and are directly applicable to cloud and HPC batch schedulers that must handle job rejection.
+
+---
+
+### EdgeHydra: Fault-Tolerant Edge Data Distribution Based on Erasure Coding
+
+*Qiang He 0001, Guobiao Zhang, Jiawei Wang 0003, Ruikun Luo *et al.**
+
+**TL;DR** — EdgeHydra uses erasure coding tailored to edge-node failure patterns to provide fault-tolerant data distribution with low redundancy overhead at the network edge.
+
+**Why notable** — Fault tolerance at the edge is an increasingly critical requirement, and this system's erasure-coding approach significantly outperforms replication in storage efficiency.
+
+---
+
+### Two-Dimensional Balanced Partitioning and Efficient Caching for Distributed Graph Analysis
+
+*Shuai Lin, Rui Wang 0076, Yongkun Li 0001, Yinlong Xu 0001 *et al.**
+
+**TL;DR** — This paper proposes a 2D balanced graph partitioning scheme combined with a caching policy that jointly minimizes communication and replication costs in distributed graph systems.
+
+**Why notable** — Graph partitioning and caching are co-dependent problems rarely treated together; the combined optimization yields substantial performance improvements with strong theoretical backing.
+
+---
+
+### Towards Universal Performance Modeling for Machine Learning Training on Multi-GPU Platforms
+
+*Zhongyi Lin, Ning Sun, Pallab Bhattacharya, Xizhou Feng *et al.**
+
+**TL;DR** — This work builds a platform-agnostic performance model for distributed ML training that accurately predicts training throughput across diverse multi-GPU configurations without per-system profiling.
+
+**Why notable** — A universal modeling framework from Owens's group removes the need for expensive empirical searches when tuning distributed training configurations, benefiting the entire ML systems community.
+

site/content/cloud-edge/digests/TPDS-2026/index.md

@@ -0,0 +1,13 @@
+---
+title: TPDS 2026 Digest
+venue: TPDS
+year: 2026
+date: '2026-01-01'
+tags: []
+paper_count: 0
+draft: false
+build:
+  list: never
+---
+
+No papers selected yet.

site/content/cloud-edge/digests/_index.md

@@ -0,0 +1,5 @@
+---
+title: Digests
+layout: digests
+draft: false
+---