Proceedings of the ACM on Measurement and Analysis of Computing Systems: POMACS: Vol. 9, No. 2. 2025

The Proceedings of the ACM on Measurement and Analysis of Computing Systems (POMACS) focuses on the measurement and performance evaluation of computer systems and operates in close collaboration with the ACM Special Interest Group SIGMETRICS. All papers in this issue of POMACS will be presented at the ACM SIGMETRICS 2025 conference on June 9-13, 2025, in Stony Brook, New York, USA.

The papers in this issue were selected during the winter submission round by the 94 members of the ACM SIGMETRICS 2025 program committee via a rigorous review process. Each paper was conditionally accepted (and shepherded), or allowed to be resubmitted to one of the subsequent two SIGMETRICS deadlines, or rejected (with resubmission allowed only after a year).

The emerging Ray-tracing cores on GPUs have been repurposed for non-ray-tracing tasks by researchers recently. In this paper, we explore the benefits and effectiveness of executing graph algorithms on RT cores. We re-design breadth-first search and triangle counting on the new hardware as graph algorithm representatives. Our implementations focus on how to convert the graph operations to bounding volume hierarchy construction and ray generation, which are computational paradigms specific to ray tracing. We evaluate our RT-based methods on a wide range of real-world datasets. The results do not show the advantage of the RT-based methods over CUDA-based methods. We extend the experiments to the set intersection workload on synthesized datasets, and the RT-based method shows superior performance when the skew ratio is high. By carefully comparing the RT-based and CUDA-based binary search, we discover that RT cores are more efficient at searching for elements, but this comes with a constant and non-trivial overhead of the execution pipeline. Furthermore, the overhead of BVH construction is substantially higher than sorting on CUDA cores for large datasets. Our case studies unveil several rules of adapting graph algorithms to ray-tracing cores that might benefit future evolution of the emerging hardware towards general-computing tasks.

We consider the problem of scheduling to minimize asymptotic tail latency in an M/G/1 queue with unknown job sizes. When the job size distribution is heavy-tailed, numerous policies that do not require job size information (e.g. Processor Sharing, Least Attained Service) are known to be strongly tail optimal, meaning that their response time tail has the fastest possible asymptotic decay. In contrast, for light-tailed size distributions, only in the last few years have policies been developed that outperform simple First-Come First-Served (FCFS). The most recent of these is γ-Boost, which achieves strong tail optimality in the light-tailed setting. But thus far, all policies that outperform FCFS in the light-tailed setting, including γ-Boost, require known job sizes. In this paper, we design a new scheduling policy that achieves strong tail optimality in the light-tailed M/G/1 with unknown job sizes. Surprisingly, the optimal policy turns out to be a variant of the Gittins policy, but with a novel and unusual feature: it uses a negative discount rate. Our work also applies to systems with partial information about job sizes, covering γ-Boost as an extreme case when job sizes are in fact fully known.

Set reconciliation is a fundamental task in distributed systems, particularly in blockchain networks, where it enables the synchronization of transaction pools among peers and facilitates block dissemination. Existing traditional set reconciliation schemes are either statistical, providing success probability as a function of the communication overhead and the size of the symmetric difference, or require parametrization and estimation of the size of the symmetric difference, which can be prone to error. In this paper, we present CertainSync, a novel reconciliation framework that, to the best of our knowledge, is the first to guarantee successful set reconciliation without any parametrization or estimators in use. The framework is rateless and adapts to the unknown symmetric difference size. The set reconciliation is guaranteed to be completed successfully whenever the communication overhead reaches a lower bound derived from the symmetric difference size and the universe size. Our framework is based on recent constructions of Invertible Bloom Lookup Tables (IBLTs) ensuring successful element listing as long as the number of elements is bounded. We provide a theoretical analysis to prove the certainty in the set reconciliation for multiple constructions. The approach is also validated by simulations, showing the ability to synchronize sets with efficient communication costs while maintaining reconciliation guarantees compared to other baseline schemes for set reconciliation. To further improve communication overhead for large universes as blockchain networks, CertainSync is extended with a universe reduction technique to minimize communication overhead. We compare and validate the extended framework UniverseReduceSync against the basic CertainSync framework through simulations using real blockchain transaction hash data from the Ethereum blockchain network. The results illustrate a trade-off between improved communication costs and maintaining reconciliation guarantees without relying on parametrization or estimators, offering a comprehensive solution for set reconciliation in diverse scenarios.

Ensuring the integrity of petabyte-scale file transfers is essential for the data gathered from scientific instruments. As packet sizes increase, so does the likelihood of errors, resulting in a higher probability of undetected errors in the packet. This paper presents a Multi-Level Error Detectio n (MLED) framework that leverages in-network resources to reduce undetected error probability (UEP) in file transmission. MLED is based on a configurable recursive architecture that organizes communication in layers at different levels, decoupling network functions such as error detection, routing, addressing, and security. Each layer L_ij at level i implements a policy P_ij that governs its operation, including the error detection mechanism used, specific to the scope of that layer. MLED can be configured to mimic the error detection mechanisms of existing large-scale file transfer protocols. The recursive structure of MLED is analyzed and it shows that adding additional levels of error detection reduces the overall UEP. An adversarial error model is designed to introduce errors into files that evade detection by multiple error detection policies. Through experimentation using the FABRIC testbed the traditional approach, with transport- and data link- layer error detection, results in a corrupt file transfer requiring retransmission of the entire file. Using its recursive structure, an implementation of MLED detects and corrects these adversarial errors at intermediate levels inside the network, avoiding file retransmission under non-zero error rates. MLED therefore achieves a 100% gain in goodput over the traditional approach, reaching a goodput of over 800 Mbps on a single connection with no appreciable increase in delay.

In this paper, we introduce DiffNEST, a diffusion-based surrogate framework for scalable, learning-driven optimization in complex computing environments. The growing complexity of modern systems often renders traditional optimization techniques inefficient, while reinforcement learning (RL)-based methods struggle with high data collection costs and hardware constraints. DiffNEST employs a diffusion model to generate realistic, continuous system traces, enabling optimization without reliance on physical hardware. DiffNEST generates realistic traces that reflect diverse workload characteristics, facilitating rapid exploration of large optimization search spaces. A case study demonstrates that DiffNEST can accelerate real-world optimization tasks, achieving up to 50% improvement in task-aware adaptive DVFS and 16% in multi-core cache allocation compared to RL approaches trained directly on physical hardware. Through fine-tuning, we show that DiffNEST can also be reused across multiple optimization tasks and workload domains, indicating its potential as a general-purpose surrogate modeling framework for system-level optimization. The code is publicly available to facilitate further research and development. https://github.com/leejunyoung8631/DiffNest.git

With the rapid development of information technology, data centers have become increasingly reliant on storage devices. However, the risk of physical damage to these devices poses significant challenges to data security. As a result, fault prediction technology has become crucial for improving the reliability of storage systems. Current research primarily focuses on analyzing hard drive operational data using machine learning or deep learning. However, most methods are trained and tested on a single model of hard drive, leading to insufficient generalization in fault detection. Large data centers typically use hard drives from multiple manufacturers and different models, with frequent replacements, making it difficult for existing methods to fully meet enterprise needs. To address these challenges, this paper proposes a hard drive fault prediction model based on pretraining and fine-tuning, named DiskAdapt. The model adopts the AdaptFormer architecture and leverages a pretraining-fine-tuning framework to extract multivariate time series features that precisely reflect the operational state of hard drives. By integrating these multivariate features and performing feature alignment operations, the model achieves accurate fault prediction. Extensive experiments conducted on multiple public datasets demonstrate that our method outperforms other baseline models.

The flexibility and scale of networks achievable by modern cloud computer architectures, particularly Kubernetes (K8s)-based applications, are rivaled only by the resulting complexity required to operate at scale in a responsive manner. This leaves applications vulnerable to Economic Denial of Sustainability (EDoS) attacks, designed to force service withdrawal via draining the target of the financial means to support the application. With the public cloud market projected to reach three quarters of a trillion dollars USD by the end of 2025, this is a major consideration. In this paper, we develop a theoretical model to reason about EDoS attacks on K8s. We determine scaling thresholds based on Markov Decision Processes (MDPs), incorporating costs of operating K8s replicas, Service Level Agreement violations, and minimum service charges imposed by billing structures. We build on top of the MDP model a Stackelberg game, determining the circumstances under which an adversary injects traffic. The optimal policy returned by the MDP is generally of hysteresis-type, but not always. Specifically, through numerical evaluations we show examples where charges on an hourly resolution eliminate incentives for scaling down resources. Furthermore, through the use of experiments on a realistic K8s cluster, we show that, depending on the billing model employed and the customer workload characteristics, an EDoS attack can result in a 4× increase in traffic intensity resulting in a 3.6× decrease in efficiency. Interestingly, increasing the intensity of an attack may render it less efficient per unit of attack power. Finally, we demonstrate a proof-of-concept for a countermeasure involving custom scaling metrics where autoscaling decisions are randomized. We demonstrate that per-minute utilization charges are reduced compared to standard scaling, with negligible drops in requests.

Network traffic classification is of great importance for network operators in their daily routines, such as analyzing the usage patterns of multimedia applications and optimizing network configurations. Internet service providers (ISPs) that operate high-speed links expect network flow classifiers to accurately classify flows early, using the minimal number of necessary initial packets per flow. These classifiers must also be robust to packet sequence disorders (drops and retransmissions) in candidate flows and capable of detecting unseen flow types that are not within the existing classification scope, which are not well achieved by existing methods. In this paper, we develop FastFlow, a time-series flow classification method that accurately classifies network flows as one of the known types or the unknown type, which dynamically selects the minimal number of packets to balance accuracy and efficiency. Toward the objectives, we first develop a flow representation process that converts packet streams at both per-packet and per-slot granularity for precise packet statistics with robustness to packet sequence disorders. Second, we develop a sequential decision-based classification model that leverages LSTM architecture trained with reinforcement learning. Our model makes dynamic decisions on the minimal number of time-series data points per flow for the confident classification as one of the known flow types or an unknown one. We evaluated our method on public datasets and demonstrated its superior performance in early and accurate flow classification. Deployment insights on the classification of over 22.9 million flows across seven application types and 33 content providers in a campus network over one week are discussed, showing that FastFlow requires an average of only 8.37 packets and 0.5 seconds to classify the application type of a flow with over 91% accuracy and over 96% accuracy for the content providers.

Fluorinated compounds, often referred to as forever chemicals, are critical in various steps of semiconductor fabrication like lithography, etching, chamber cleaning, and others. Forever chemical emissions can exhibit global warming potentials thousands of times greater than carbon dioxide and persist in the atmosphere for millennia. Despite their severe impact, most sustainability works in computer systems have focused on carbon emissions alone. We address this gap by introducing ForgetMeNot, a modeling tool that quantifies fluorinated compound emissions by integrating fabrication facility-specific practices and hardware specifications, and validate its accuracy using real-world emission data from fabrication facilities. We show how ForgetMeNot can enable fabrication facilities to optimize design and material usage decisions for emission reduction and provide researchers with a methodology to calibrate emission estimates for hardware designs. When ForgetMeNot is applied to analyze emissions for manufacturing CPUs, DRAM, and storage, it illustrates how hardware generations, lithography techniques, and capacities impact fluorinated compound emissions. Finally, we demonstrate how datacenter operators can assemble low-emission servers while balancing performance demands. By factoring in fluorinated emissions into manufacturing decisions, ForgetMeNot paves the way for building more sustainable systems.

Modern cloud computing workloads are composed of multiresource jobs that require a variety of computational resources in order to run, such as CPU cores, memory, disk space, or hardware accelerators. A single cloud server can typically run many multiresource jobs in parallel, but only if the server has sufficient resources to satisfy the demands of every job. A scheduling policy must therefore select sets of multiresource jobs to run in parallel in order to minimize the mean response time across jobs --- the average time from when a job arrives to the system until it is completed. Unfortunately, achieving low response times by selecting sets of jobs that fully utilize the available server resources has proven to be a difficult problem.

In this paper, we develop and analyze a new class of policies for scheduling multiresource jobs, called Markovian Service Rate (MSR) policies. While prior scheduling policies for multiresource jobs are either highly complex to analyze or hard to implement, our MSR policies are simple to implement and are amenable to response time analysis. We show that the class of MSR policies is throughput-optimal in that we can use an MSR policy to stabilize the system whenever it is possible to do so. We also derive bounds on the mean response time under an MSR algorithm that are tight up to an additive constant. These bounds can be applied to systems with different preemption behaviors, such as fully preemptive systems, non-preemptive systems, and systems that allow preemption with setup times. We show how our theoretical results can be used to select a good MSR policy as a function of the system arrival rates, job service requirements, the server's resource capacities, and the resource demands of the jobs.

Microservice applications typically employ a technique known as connection subsetting to ensure resource-efficient and stable communication. In this technique, upstream containers selectively route requests to a limited subset of downstream counterparts via persistent connections. However, the interdependency in microservice applications and complex runtime environments pose significant challenges for effective connection subsetting, rendering traditional strategies notably inefficient.

In this paper, we present Microns, a connection subsetting framework designed for microservices in shared clusters. At the application level, Microns effectively handles the complex call dependencies in applications and meticulously determines the number of connections maintained by each pair of dependent microservices. At the microservice level, Microns manages the connection relationships between dependent containers according to their respective contributions on end-to-end latency. Experiments across microservice benchmarks and large-scale simulations demonstrate that Microns achieves a significant reduction on end-to-end latency by over 74.4% compared with the state-of-the-art strategies.

The paper studies the (end-to-end) waiting and sojourn times in tandem queues with general arrivals and light-tailed service times. It is shown that the tails of the corresponding distributions are subject to polynomial-exponential upper bounds, whereby the degrees of the polynomials depend on both the number of bottleneck queues and the 'light-tailedness' of the service times. Closed-form bounds constructed for a two-queue tandem with exponential service times are shown to be numerically sharp, improve upon alternative large-deviations bounds by many orders of magnitude, and recover the exact results in the case of Poisson arrivals.

We introduce and study a multi-class online resource allocation problem with group fairness guarantees. The problem involves allocating a fixed amount of resources to a sequence of agents, each belonging to a specific group. The primary objective is to ensure fairness across different groups in an online setting. We focus on three fairness notions: one based on quantity and two based on utility. To achieve fair allocations, we develop two threshold-based online algorithms, proving their optimality under two fairness notions and near-optimality for the more challenging one. Additionally, we demonstrate a fundamental trade-off between group fairness and individual welfare using a novel representative function-based approach. To address this trade-off, we propose a set-aside multi-threshold algorithm that reserves a portion of the resource to ensure fairness across groups while utilizing the remaining resource to optimize efficiency under utility-based fairness notions. This algorithm is proven to achieve the Pareto-optimal trade-off. We also demonstrate that our problem can model a wide range of real-world applications, including network caching and cloud computing, and empirically evaluate our proposed algorithms in the network caching problem using real datasets.

Motivated by the emerging paradigm of resource allocation that integrates classical objectives, such as cost minimization, with societal objectives, such as carbon awareness, this paper proposes a general framework for the online fair allocation of reusable resources. Within this framework, an online decision-maker seeks to allocate a finite resource with capacity C to a sequence of requests arriving with unknown distributions of types, utilities, and resource usage durations. To accommodate diverse objectives, the framework supports multiple actions and utility types, and the goal is to achieve max-min fairness among utilities, i.e., maximize the minimum time-averaged utility across all utility types. Our performance metric is an (α,β)-competitive guarantee of the form: ALG ≥ α • OPT^* - O(T^β-1),; α, β ∈ (0, 1], where OPT^* and ALG are the time-averaged optimum and objective value achieved by the decision maker, respectively. We propose a novel algorithm that achieves a competitive guarantee of (1-O(√(log C/C)), 2/3) under the bandit feedback. As resource capacity increases, the multiplicative competitive ratio term 1-O(√ logC/C) asymptotically approaches optimality. Notably, when the resource capacity exceeds a certain threshold, our algorithm achieves an improved competitive guarantee of (1, 2/3). Our algorithm employs an optimistic penalty-weight mechanism coupled with a dual exploration-discarding strategy to balance resource feasibility, exploration, and fairness among utilities.

Recently, flash-based solid state drives (SSDs) have become a primary storage solution due to their advantages over hard-disk drives. Nonetheless, SSD management presents unique challenges. First, SSDs update data by writing a new copy to a clean slot, rather than overwriting old data. Second, SSDs support cleaning of entire blocks, while slots cannot be cleaned individually. Third, when cleaning a block, any valid data it stores must first be rewritten to another location, which adversely affects the SSD endurance and throughput.

In this work, we address the SSD management problem, where the objective is to minimize the number of rewrites in SSDs. We approach the problem from a theoretical perspective, analyzing algorithms in a worst-case fashion. Motivated by recent advances in machine learning, we consider a learning-augmented setting where the algorithm has access to a predictive oracle, with performance guarantees expressed as a function of the error in the oracle's output.

Our main contribution is Gladiator, a novel online algorithm that optimally leverages predictions to enhance the performance of SSDs. Compared to prior work, Gladiator requires no additional non-volatile memory and is less sensitive to prediction errors. We further demonstrate the effectiveness of Gladiator under reasonable assumptions on the input distribution, and extend it to an extremely efficient offline algorithm. Empirical results confirm its superiority over state-of-the-art practical solutions across diverse SSD workloads.

Graph states are a class of important multiparty entangled quantum states, of which Bell pairs are the special case. Realizing a robust and fast distribution of arbitrary graph states in the downstream layer of the quantum network is essential for enabling large-scale quantum networks. To address this, we propose a novel quantum network protocol, called P2PGSD, inspired by the classical Peer-to-Peer network. This protocol efficiently implements general graph state distribution in the network layer, demonstrating significant advantages in resource efficiency and scalability, particularly for sparse graph states. An explicit mathematical model for the general graph state distribution problem has also been constructed, above which the intractability for a wide class of resource minimization problems is proved and the optimality of the existing algorithms is discussed. Moreover, we leverage the space-time quantum network for memory management in network challenges, drawing inspiration from special relativity. We suggest a universal quantum distributed computation framework to exploit the strengths of our protocols, as confirmed by numerical simulations that reveal up to a 50% enhancement for general sparse graph states. This work marks a significant step toward resource-efficient multiparty entanglement distribution for diverse network topologies.

The prosperity of Ethereum has led to a rise in phishing scams. Initially, scammers lured users into transferring or granting tokens to Externally Owned Accounts (EOAs). Now, they have shifted to deploying phishing contracts to deceive users. Specifically, scammers trick victims into either directly transferring tokens to phishing contracts or granting these contracts control over their tokens. Our research reveals that phishing contracts have resulted in significant financial losses for users. While several studies have explored cybercrime on Ethereum, to the best of our knowledge, the understanding of phishing contracts is still limited.

In this paper, we present the first empirical study of phishing contracts on Ethereum. We first build a sample dataset including 790 reported phishing contracts, based on which we uncover the key features of phishing contracts. Then, we propose to collect phishing contracts by identifying suspicious functions from the bytecode and simulating transactions. With this method, we have built the first large-scale phishing contract dataset on Ethereum, comprising 37,654 phishing contracts deployed between December 29, 2022 and January 1, 2025. Based on the above dataset, we collect phishing transactions and then conduct the measurement from the perspectives of victim accounts, phishing contracts, and deployer accounts. Alarmingly, these phishing contracts have launched 211,319 phishing transactions, leading to 190.7 million in losses for 171,984 victim accounts. Moreover, we identify a large-scale phishing group deploying 85.7% of all phishing contracts, and it remains active at present. Our work aims to serve as a valuable reference in combating phishing contracts and protecting users' assets.

The fusion of serverless computing and deep learning (DL) has led to serverless inference, offering a promising approach for developing and deploying scalable and cost-efficient deep learning inference services (DLISs). However, the challenge of cold start presents a significant obstacle for DLISs, where DL model size greatly impacts latency. Existing studies mitigate cold starts by extending keep-alive times, which unfortunately leads to decreased resource utilization efficiency. To address this issue, we introduce PipeCo, a system designed to alleviate DLIS cold start. The core concept of PipeCo is to achieve the miniaturization and pipelining of DLIS cold start. Firstly, PipeCo utilizes a vertical partitioning approach to divide each DLIS into multiple slices, prewarming slices in a sequential and overlapping manner to decrease the overall cold-start latency. Secondly, PipeCo employs an attention-based prediction mechanism to estimate periodic patterns in requests and idle containers for scheduling slices. Thirdly, PipeCo incorporates a similarity-based container matcher for the reuse of idle containers. We implemented a prototype of PipeCo on the OpenFaaS platform and conducted extensive experiments using three real-world DLIS repositories. The results demonstrate that PipeCo effectively decreases end-to-end (E2E) latency by up to 62.67% on CPU and 58.81% on GPU clusters and reduces the overall resource usage by 65.31% compared to five state-of-the-art baselines.

In the early 2010s, the dramatic increase in the bandwidth of datacenter network links led to the emergence of microsecond-scale congestion events, a challenging phenomenon known as microbursts. Although microbursts may seem very short and small, they pose a significant challenge and can have a severe negative impact on the performance of datacenter networks. Despite the various methods proposed to mitigate microbursts, recent studies show that microbursts and their negative effects still persist in datacenters. In this paper, we show that the primary reason for observing low performance from microburst mitigation methods is that these methods are used in situations or scenarios where they are not suitable or effective. We first discuss this issue by dissecting various microburst mitigation approaches, demonstrating that each method's effectiveness is limited to microbursts with particular characteristics, rather than being a comprehensive solution. Then, we provide a comprehensive measurement and analysis of the diverse characteristics of microbursts, with particular attention to various applications' influences. While intermediate and lower layers of the network stack are predominantly identified as the primary origins of microbursts, our findings reveal that microbursts generated in different applications exhibit different characteristics, which can significantly affect the performance of various mitigation methods. This indicates that optimal microburst mitigation in datacenters requires careful deployment of techniques based on the characteristics of hosted applications. As illustrative examples, through our analysis, we identify which microburst mitigation techniques are effective and which are ineffective for several widely-used datacenter applications.

Accurately predicting 5G bandwidth in vehicular mobility scenarios is essential for optimizing real-time communication (RTC) systems in a range of emerging vehicular applications, such as autonomous driving, in-car video conferencing, vehicular augmented reality (AR), and remote driving in dynamic urban environments. In this paper, we propose Prophet, a causality-aware Transformer model designed to forecast 5G throughput by capturing the complex causal relationships between control-plane 5G network events (e.g., handovers) and environmental factors (e.g., signal strength). Our key contributions include: (1) a wavelet-based encoder that efficiently captures long-term trends through multi-scale signal decomposition; (2) a control-plane causality attention mechanism in the decoder that focuses on localized, short-term throughput variations triggered by network events; and (3) a Granger causality attention mechanism that enhances prediction accuracy by emphasizing historically significant data patterns. Prophet surpasses State-Of-The-Art (SOTA) models like random forest, Long Short-Term Memory (LSTM), and other SOTA transformers in both accuracy and scalability.

In mobile communication systems, the increasing densification of radio access networks is creating unprecedented computational stress for baseband processing, threatening the industry's sustainability, and new computing paradigms are urgently needed to improve the efficiency of wireless processors. Quantum computing promises to revolutionize many computing-intensive tasks across diverse fields and therefore may be the key to realizing ultra-dense next-generation mobile systems that remain economically and environmentally viable. This paper investigates the potential of Quantum computing to accelerate Forward Error Correction (FEC), the most compute-heavy component of wireless processors. We first propose Qu4Fec, a novel solution for decoding Low-Density Parity Check (LDPC) codes on Quantum Processing Units (QPUs), which we show to outperform state-of-the-art approaches, by reducing the Block Error Rate (BLER) by nearly an order of magnitude in simulation. We then implement Qu4Fec on a real-world QPU platform to study its practical viability and performance. Our experiments reveal that current cutting-edge QPU architectures curb the capabilities of FEC and expose the underlying factors, including long qubit chains, scaling, and quantization. Based on these insights, we suggest original blueprints for future QPUs that can better support Quantum-based wireless processors. Overall, this paper provides a reliable reality check for the feasibility of wireless processing on Quantum annealers: as QPUs start to be considered part of a possible 6G landscape, our work may open new research paths towards the design of FEC methods for Quantum-powered wireless processors.

Quantum networks are essential infrastructure for enabling large-scale and long-distance quantum communications but face significant challenges in routing optimization and resource allocation due to their probabilistic nature and quantum resource limitations. Existing approaches typically tackle these problems in isolation, often by simply applying classical routing algorithms, maximizing the overall profit to allocate resources without considering fairness, or improving fairness in an ad-hoc way without a rigorous model. This paper proposes a general framework to systematically address these challenges. First, we conduct a thorough analysis of quantum network metrics using routing algebra as the mathematical foundation, and design provably optimal routing algorithms to tackle the unique challenges arising from their probabilistic characteristics. Second, we formulate an optimization model that simultaneously considers fairness among concurrent requests while respecting various quantum resource constraints, and design efficient near-optimal heuristics to solve it. The proposed framework provides both theoretical insights and practical solutions for the design and management of future quantum networks.

Source localization in graphs involves identifying the origin of a phenomenon or event, such as an epidemic outbreak or a misinformation source, by leveraging structural graph properties. One key concept in this context is the metric dimension, which quantifies the minimum number of strategically placed sensors needed to uniquely identify all vertices based on their distances. While powerful, the traditional metric dimension imposes a stringent requirement that every vertex must be uniquely identified, often necessitating a large number of sensors.

In this work, we relax the metric dimension and allow vertices at a graph distance less than k to share identical distance profiles relative to the sensors. This relaxation reduces the number of sensors needed while maintaining sufficient resolution for practical applications like source localization and network monitoring. We provide two main theoretical contributions: an analysis of the k-relaxed metric dimension in deterministic trees, revealing the interplay between structural properties and sensor placement, and an extension to random trees generated by branching processes, offering insights into stochastic settings.

We also conduct numerical experiments across a variety of graph types, including random trees, random geometric graphs, and real-world networks. For graphs with loops, we use a greedy algorithm to obtain an upper-bound on the relaxed metric dimension. The results show that the relaxed metric dimension is significantly smaller than the traditional metric dimension. Furthermore, the number of vertices indistinguishable from any given target vertex always remains small. Finally, we propose and evaluate a two-step localization strategy that balances the trade-off between resolution and the number of sensors required. This strategy identifies an optimal relaxation level that minimizes the total number of sensors across both steps, providing a practical and efficient approach to source localization.

Datacenter network topology contains multiple paths between server machines, with each path assigned a weight. Software switches perform traffic splitting, an essential networking operation in datacenters. Previous studies leveraged software switches to distribute network connections across paths, under the assumption that the software switches accurately divide connections according to path weights. However, our experiments reveal that current traffic splitting techniques exhibit significant inaccuracy and resource inefficiency. Consequently, real-world datacenter services (e.g., data mining and deep learning) experience communication completion times that are ∼2.7× longer than the ideal. To address these problems, we propose VALO, a new traffic splitting technique for software switches, to accomplish two goals: high accuracy and resource-efficiency. For the goals, we introduce new concepts: score graph and VALO gravity. We implement VALO using the de-facto software switch, Open vSwitch, and evaluate it thoroughly. On average, VALO achieves 13.1× better accuracy and 25.4× better resource efficiency compared to existing techniques, with maximum improvements reaching up to 34.8× and 67.7×, respectively. As a result, VALO demonstrates 1.3×-2.5× faster average communication completion times for real-world datacenter services compared to existing techniques.

User interrupts (UINTR) is a new hardware feature available in recent Intel Xeon processors. It enables a CPU to send, receive, and handle hardware inter-processor interrupts directly in user mode, meaning without the intervention of the OS kernel. In this paper, we shed light on the inner working of this facility and investigate, with detailed performance and overhead measurements considering deployments on physical machines and virtual machines with Linux and KVM, how it can be leveraged for more efficient inter-process communications, as an alternative to OS (Unix) signals. With UINTR, preemptive user-level thread schedulers can achieve quantum lengths in the microsecond scale.

Given the increasing residential Internet use, a thorough understanding of what services are used and how they are delivered to residential networks is crucial. However, access to residential traces is limited due to their proprietary nature. Most prior work used campus datasets from academic buildings and undergraduate dorms, and the few studies with residential traces are often outdated or use data unavailable to other researchers. We provide access to a new residential dataset-we have been collecting traffic from ~1000 off-campus residences that house faculty, postdocs, graduate students, and their families. Although our residents are university affiliates, our dataset captures their activity at home, and we show that this dataset offers a distinct perspective from the campus and dorm traffic. We investigate the serving infrastructures and services accessed by the residences, revealing several interesting findings: peer-to-peer activity is notable, comprising 47% of the total flow duration; third-party CDNs host many services but serve much less traffic (e.g., Cloudflare hosts 19% of domains but only 2% of traffic); and 11 of the top 100 services that have nearby servers often serve users from at least 1,000km farther away. This broad analysis, as well as our data sharing, pushes toward a more thorough understanding of Internet service usage and delivery, motivating and supporting future research.

Container technology, characterized by its convenience in deployment and exceptional performance, has emerged as a dominant force in the realm of cloud computing. However, the shared kernel among different containers and the common practice of running multiple applications within a single container pose threats to user data from malicious co-resident containers or other malicious programs within the same container. To address this problem, we introduce a novel container architecture design - UniContainer. UniContainer partitions original containers, allowing each component to run within an independent customized Unikernel, thereby enhancing isolation both between containers and within containers. We implement a prototype of UniContainer based on Unikraft, enabling automated analysis of target container system call logs and configuration of optimal Unikraft images, while preserving the convenience of container technology deployment. Through experimental evaluation, we validate the effectiveness and performance of UniContainer, maximizing the outstanding performance benefits of container technology.

Count-Min Sketch with Conservative Updates ( CMS-CU ) is a memory-efficient hash-based algorithm used to estimate the occurrences of items within a data stream. CMS-CU employs d hash functions and a total of m counters arranged in d rows, with each hash function mapping an item to one counter per row. In this paper, we study a similar algorithm, which we refer to as CU-S, where d hash functions map each item to d distinct counters in a single array of size m. Specifically, we present an analytical method to quantify the trade-off between memory usage and the Counting Error (CE ) of an item in CU-S, defined as the discrepancy between the estimated and actual number of its occurrences. The first result of this paper shows that items absent from the stream experience the highest CE. We refer to their error as the Unseen items Error (UE ). The second result is an upper bound on UE of any stream, expressed in terms of the Reference Error (RE ), which is UE of a reference stream where each item appears at most once. We also identify streams for which this bound is provably tight. The direct computation of RE involves dealing with an infinite state space Markov process similar to the Balls and Bins model with the Power of Choice, but more difficult to handle analytically. Instead, we construct two finite state space Markov processes, parametrized by a positive integer g, that bound the original chain and yield efficiently computable lower and upper bounds on RE. Increasing g narrows the gap between these bounds and enlarges the state space to ((m+g-d)/g), thus increasing the computation time. For d=m-1, g=1, and as m → ∞, we prove that the lower and upper bounds coincide. Our bounds are accurate for small values of g and for more general values of m and d, as shown by numerical computation. Finally, simulations on various streams confirm that bounding RE in this manner enables efficient and accurate computation of UE.

In large-scale information systems, storage device performance continues to improve while workloads expand in size and access characteristics. This growth puts tremendous pressure on caches and storage hierarchy in terms of concurrent throughput. However, existing cache eviction policies often struggle to provide adequate concurrent throughput due to their reliance on coarse-grained locking mechanisms and complex data structures. This paper presents a practical approach to cache eviction algorithm design, called Mobius, that optimizes the concurrent throughput of caches and reduces cache operation latency by utilizing lock-free data structures, while maintaining comparable hit ratios. Mobius includes two key designs. First, Mobius employs two lock-free FIFO queues to manage cache items, ensuring that all cache operations are executed efficiently in parallel. Second, Mobius integrates a consecutive detection mechanism that merges multiple modifications during eviction into a single operation, thereby reducing data races. Extensive evaluations using both synthetic and real-world workloads from high-concurrency clusters demonstrate that Mobius achieves a concurrent-throughput improvement ranging from 1.2× to 8.5× over state-of-the-art methods, while also maintaining lower latency and comparable cache hit ratios. The implementation of Mobius in CacheLib and RocksDB highlights its effectiveness in enhancing cache performance in practical scenarios.