In the erasure-coded storage systems, multiple related blocks have to be retrieved from other surviving nodes to repair a failed block. This incurs significant communication overhead with the surging scale of distributed storage systems. To mitigate the bandwidth bottleneck, in-network repair (INR) has emerged as a promising transport paradigm, which migrates the aggregation operations from the repair node to the programmable hardware, such as Intel Tofino switches. However, due to the limited on-chip memory size of these switches, the INR can degrade to the most primitive incast-type transmission, leading to massive traffic volume and hindered repair throughput. While we notice that, there are spare CPU cores in the storage servers that can be leveraged as alternative computing resources. With this intuition, we propose SINA, a Server-assisted In-Network repair Acceleration framework in this paper, which leverages the spare servers to assist aggregation operations when the programming switches' memory size is scarce for failure repair. We formulate this problem by adjusting the aggregation modes across the involved racks and solve this NP-hard problem using the Gurobi optimization solver. For all we know, this is the first work exploring spare servers for assisting the memory-scarce INR in erasure-coded storage systems. We have implemented SINA on an FPGA-based prototype system, and the experimental results show that SINA can ensure fault tolerance and accelerate failure repair by$5.0 \times$compared to the conventional methods.

Edge computing is an emerging paradigm poised to process a substantial portion of latency-sensitive and computation-intensive tasks through edge service providers (ESPs). However, these ESPs typically operate independently and locally to serve their registered users. When processing burst tasks, the ESPs have to either scale up their respective capacities by introducing additional hardware or compromise user experience by rejecting some user requests, leading to high commercial investment or service degradation. Inspired by the promise of the win-win situation for ESPs and users, we envision a novel task offloading strategy that realizes the following rationales simultaneously: 1) collaborative service, 2) rapid response, and 3) sustainable profitability, while the existing methods fail to achieve them at one shot. To this end, we report CoEdge, a collaborative architecture for efficient task offloading among multiple ESPs in the edge network, aiming at simultaneously minimizing service delay for users and enhancing service profit for ESPs. To achieve this, CoEdge employs a central optimizer to implement a two-stage strategy that determines the task scheduling and service pricing hierarchically. We then formulate these problems and prove their NP-hardness. Additionally, we also propose efficient approximate algorithms to accommodate large-scale computing scenarios with low complexity. Experimental results using real-world datasets demonstrate that our CoEdge can significantly reduce service delay by 2.87x to 4.15x for users and considerably increase service profit by 32% for ESPs.

Currently, deduplication techniques are utilized to minimize the space overhead by deleting redundant data blocks across large-scale servers in data centers. However, such a process exacerbates the fragmentation of data blocks, causing more cross-server file retrievals with plummeting retrieval throughput. Some attempts prefer better file retrieval performance by confining all blocks of a file to one single server, resulting in non-trivial space consumption for more replicated blocks across servers. An ideal network storage system, in effect, should take both the deduplication and retrieval performance into account by implementing reasonable assignment of the detected unique blocks. Such a fine-grained assignment requires an accurate and comprehensive abstraction of the files, blocks, and the file-block affiliation relationships. To achieve this, we innovatively design the weighted hypergraph to profile the multivariate data correlations. With this delicate abstraction in place, we propose HyperPart, which elegantly transforms this complex block allocation problem into a hypergraph partition problem. For more general scenarios with dynamic file updates, we further propose a two-phase incremental hypergraph repartition scheme, which mitigates the performance degradation with minimal migration volume. We implement a prototype system of HyperPart, and the experiment results validate that it saves around 50% of the storage space and improves the retrieval throughput by approximately 30% of state-of-the-art methods under the balance constraints.

As an ambitious training paradigm, federated learning has garnered increasing attention in recent years, which enables collaborative training of a global model without accessing users’ private data. However, due to the simultaneous and constant model updates gathering from massive distributed clients, the central server generally becomes a performance bottleneck. Additionally, the stateful aggregation (retaining all the updates from each client) conducted by the central server further poses potential threats to privacy, since it may recover the raw data based on such model updates inversely. The state-of-the-art methodologies, however, fail to address these two problems concurrently and efficiently. To this end, we propose GAIN, a secure aggregation acceleration service for federated learning. At its core, GAIN leverages programmable switches deployed at the edge network to aggregate model updates in a stateless manner before transmitting them to the central server. Consequently, GAIN can accelerate the transmission and aggregation of model updates while eliminating the chance of recovering private data. We evaluate the performance of GAIN through FPGA-based experiments and large-scale simulations. The results show that GAIN can effectively reduce bandwidth overhead and achieve up to 4.11× training throughput acceleration while prioritizing privacy protection.

The performance of distributed applications has long been hindered by network communication, which has emerged as a significant bottleneck. At the core of this issue, the many-to-one incast transfer stands out as one of the primary culprits. Existing works typically decompose the transmission into multiple concurrent sub-processes and utilize servers to aggregate relevant traffic, thus avoiding the incast transfer. However, limited by their theoretical bounds, these methods can only obtain limited performance improvement. In this paper, we discover that leveraging network devices for aggregating incast traffic proves highly effective in surpassing such limitations, while the advent of programmable switches further makes this envision practical. Based on this, we propose GISA as a solution for providing network acceleration across diverse distributed applications. GISA offers generic and uniform interfaces to various applications along with a switch resource sharing mechanism and policy for concurrent tasks. It also ensures correct and reliable transport while minimizing overhead through a low-overhead routing mechanism. Our FPGA-based prototype demonstrates that GISA can achieve line-rate processing when performing data aggregation with minor traffic overhead. Additionally, it supports a wide range of concurrent applications with little development effort.

In federated learning, sending the trained models (instead of raw data) from clients to the central server can surely decrease the volume of exchanged data and preserve data privacy to some extent. However, the central server can still be a system bottleneck due to the simultaneous and constant model gathering from massive distributed clients. Besides, the central server conducts stateful aggregation (retaining all the updates from each client), making it a potential threat to privacy, since it may recover the raw data based on such model updates inversely. The state-of-the-art methodologies, however, fail to address these two problems concurrently. To this end, we propose GAIN, a secure aggregation acceleration service for federated learning. At its core, GAIN aggregates the model updates at the programmable ingress switches in a stateless manner (storing the aggregated model parameters from the clients temporarily rather than permanently) before proceeding to the central server. Consequently, GAIN can accelerate the transmission and aggregation of model parameters while eliminating the chance of data recovery. We implemented a prototype of GAIN on an FPGA-based testbed to validate its performance. The results demonstrate that GAIN can achieve up to 4.11x speedup in training throughput and reduce up to 86.5% of traffic overhead. Furthermore, through theoretical analysis, we illustrate that GAIN can achieve even more substantial performance gains with a larger number of clients while guaranteeing privacy protection.

Service Function Chaining (SFC) dynamically links multiple Virtual Network Functions (VNFs) to provide flexible and scalable network services for network entities and users. Implementing SFCs at the network edge provides instant VNF service yet is confined by the limited edge resources. Existing strategies suggest either to deploy new VNFs for diverse service provision or to deploy more installed VNFs for reliable service provision. However, these one-sided optimizations fail to realize comprehensive improvements in the network service quality. To this end, the motivation of this paper is to consider a more comprehensive SFC deployment plan to provide more efficient network services. In this paper, we propose DeepSFC, an online SFC deployment scheme at network edge. Our DeepSFC considers the impact of resource allocations and deployment locations on the average latency of overall service requests. It realizes an elegant trade-off between the diversity and the availability of SFCs by adopting the Deep Reinforcement Learning (DRL) method. To be specific, we first determine the type and number of VNFs that need to be deployed. Thereafter, we optimize the deployment locations of these chosen VNFs in the service chain, considering the impact of dynamic bandwidth in the real network. For more general scenarios wherein users’ service requirements change or the deployed server crashes, we further relocate the VNF deployment with the joint consideration of performance degradation and migration cost. Evaluation results show that DeepSFC outperforms its competitors in various experimental settings and responds the requests with lower average latency.

To repair a failed block in the erasure-coded storage system, multiple related blocks have to be retrieved from other storage nodes across the network. Such a process can lead to significant incast-type repair traffics and delays. The existing efforts mainly try to schedule the transmission of the requested blocks across different storage nodes to avoid network congestion. At their cores, they utilize part of the involved hosts to rely on or aggregate the file blocks from others. While we notice that, the programmability and capability of today’s network devices (i.e., routers and switches) bring a great opportunity to further speed up the repair progress by aggregating the file blocks with such devices. By mitigating the aggregation operations from the network edges to network cores, it is possible to save more time and bandwidth. With this intuition, we propose Paint, a parallelized in-network aggregation framework for failure repair. Paint utilizes programmable switches to aggregate relevant data and improves the repair performance by implementing multiple parallelized repair pipelines. We propose a series of novel and time-friendly algorithms to construct the routing paths for Paint and design the Aggregation Control Protocol to implement Paint in production clusters. For all we know, this is the first work to explore and implement parallelized in-network repair with programmable switches. The extensive experiments on the prototype system and real-world datasets indicate that Paint can significantly improve repair performance while effectively reducing bandwidth overhead.

Storing files at the network edge has become a new paradigm of storage systems, which is promising to mitigate network congestion and reduce file retrieval latency. However, the traditional file storage scheme cannot effectively meet the requirements of rapid indexing and load balance when applied directly to the edge. Moreover, due to the dynamic nature of the edge environment where edge servers can join or leave at will, it is necessary for the storage scheme to adjust with minimal disruption. In this paper, we propose EdgeAnchor, a novel edge storage strategy that is composed of the two-layer hash mappings. The first layer, file-to-bucket mapping, adopts the pseudo-deletion algorithm to deal with the variations in file size, while the second layer utilizes the multiple bucket-to-server mapping to adapt to the heterogeneity in the servers’ storage capacities. Furthermore, EdgeAnchor constructs a list of deleted or added working sets for each bucket and creates a dictionary for the mappings between buckets and edge servers. In the manner, EdgeAnchor ensures a rapid file index and balances server load at the dynamic network edge. We also attach the mathematical analyses to EdgeAnchor, which theoretically proves its logarithmic complexity of hash operations and memory accesses. The experiments conducted on real-world datasets demonstrate that EdgeAnchor achieves the file index throughput twice as high as that of Consistent Hashing, under the constraints of load balance. Additionally, it ensures a low and stable data migration volume, when adding or removing edge servers consecutively.

The traditional migration methods are confronted with formidable challenges when data deduplication technologies are incorporated. First, the deduplication creates data-sharing dependencies in the stored files; breaking such dependencies in migration may attach extra space overhead. Second, the redundancy elimination makes the storage system reserves only one copy for each storage file, and heightens the risk of data unavailability. The existing methods fail to tackle them in one shot. To this end, we propose Jingwei, an efficient and adaptive data migration strategy for deduplicated storage systems. To be specific, Jingwei tries to minimize the extra space cost in migration for space efficiency. Meanwhile, Jingwei realizes the service adaptability by encouraging replicas of hot files to spread out their data access requirements. We first model such a problem as an integer linear programming (ILP) and solve it with a commercial solver when only one empty migration target server is allowed. We then extend this problem to a scenario wherein multiple non-empty target servers are available for migration. We solve it by effective heuristic algorithms based on the Bloom Filter-based data sketches. The Jingwei strategy can suffer from performance degradation when the heat degree varies significantly. Therefore, we further present incremental adjustment strategies for the two scenarios, which adjust the number of block replicas and their locations in an incremental manner. The mathematical analyses and trace-driven experiments show the effectiveness of our Jingwei strategy. To be specific, Jingwei fortifies the file replicas by 25% with only 5.7% of the extra storage space, compared with the latest “Goseed” method. With the small extra space cost, the file retrieval throughput of Jingwei can reach up to 333.5 Mbps, which is 12.3% higher than that of the Random method.

Placing popular data at the network edge helps reduce the retrieval latency, but it also brings challenges to the limited edge storage space. Currently, using available yet not necessarily reliable edge resources is common sense for edge space expansion, while deploying deduplication storage strategies is a general method for better space utilization. However, a contradiction arises when jointly implementing data deduplication with unreliable edge resources. On the one hand, the deduplication policy stipulates that any data chunk can be stored exactly once; on the other hand, the use of unreliable resources imposes that data should be backed up for the seek of file availability. To resolve such contradiction, we propose MEAN, a deduplication-enabled storage system using unreliable resources at the network edge. The core idea of MEAN is to place similar files together for better deduplication and maintain replicas of popular files for higher reliability. We first formulate this problem and prove its NP-hardness, then provide efficient heuristics based on similarity-aware hierarchical clustering. Three different reliability scenarios are comprehensively considered to develop our algorithms. We also implement a prototype system and evaluate the performance of MEAN with a real-world dataset. The results show that MEAN can fortify the file hit ratio under unreliable environments by 77% while reducing the file retrieval delay up to 71%, compared with the state-of-the-art approach.

The traditional migration methods are confronted with formidable challenges when data deduplication technologies are incorporated. Firstly, the deduplication creates data-sharing dependencies in the stored files; breaking such dependencies in migration would attach extra space overhead. Secondly, the redundancy elimination heightens the risk of data unavailability during server crashes. The existing methods fail to tackle them at one shot. To this end, we propose Jingwei, an efficient and adaptable data migration strategy for deduplicated storage systems. To be specific, Jingwei tries to minimize the extra space cost in migration for space efficiency. Meanwhile, Jingwei realizes the service adaptability by encouraging replicas of hot data to spread out their data access requirements. We first model such a problem as an integer linear programming (ILP) and solve it with a commercial solver when only one empty migration target server is allowed. We then extend this problem to a scenario wherein multiple non-empty target servers are available for migration. We solve it by effective heuristic algorithms based on the Bloom Filter-based data sketches. Trace-driven experiments show that Jingwei fortifies the file replicas by 25%, while only 5.7% of the extra storage space is occupied compared with the latest "Goseed" method.

Edge computing responds to users’ requests with low latency by storing the relevant files at the network edge. Various data deduplication technologies are currently employed at edge to eliminate redundant data chunks for space saving. However, the lookup for the global huge-volume fingerprint indexes imposed by detecting redundancies can significantly degrade the data processing performance. Besides, we envision a novel file storage strategy that realizes the following rationales simultaneously: 1) space efficiency, 2) access efficiency, and 3) load balance, while the existing methods fail to achieve them at one shot. To this end, we report LOFS, a Lightweight Online File Storage strategy, which aims at eliminating redundancies through maximizing the probability of successful data deduplication, while realizing the three design rationales simultaneously. LOFS leverages a lightweight three-layer hash mapping scheme to solve this problem with constant-time complexity. To be specific, LOFS employs the Bloom filter to generate a sketch for each file, and thereafter feeds the sketches to the Locality Sensitivity hash (LSH) such that similar files are likely to be projected nearby in LSH tablespace. At last, LOFS assigns the files to real-world edge servers with the joint consideration of the LSH load distribution and the edge server capacity. Trace-driven experiments show that LOFS closely tracks the global deduplication ratio and generates a relatively low load std compared with the comparison methods.

Cuckoo filter (CF) and its variants are emerging as replacements of Bloom filters in various networking and distributed systems to support efficient set representation and membership testing. Cuckoo filters store item fingerprints directly with two candidate buckets and a reallocation scheme is implemented to mitigate the bucket overflow problem for higher space utilization. Such a reallocation scheme, once triggered, however, can be time-consuming. This shortcoming makes the existing CFs not applicable for insertion-intensive scenarios such as online applications wherein the items join and leave frequently. To this end, in this paper, we propose the Vertical Cuckoo filter (VCF) which extends the standard Cuckoo filter by providing more candidate buckets to each item. Another challenging issue with such a design is how to ensure that the candidate buckets can be indexed by each other such that no additional hash computation and item access are necessary during fingerprint reallocation. Therefore, we present the vertical hashing, which indexes the candidate buckets with the fingerprint and given bitmasks. We further generalize and improve the VCF by realizing$k$(≥ 4) candidate buckets and avoiding unnecessary computation. The comprehensive experiments indicate that VCF outperforms its same kinds in terms of space utilization and insertion throughput, with a slight compromise of lookup speed.

City-wide package delivery becomes popular due to the dramatic rise of online shopping. In order to speed up the package delivery process without increasing the delivery cost, a promising system has been proposed, which leverages the crowdsourced taxis. Many efforts have been done on this novel system in recent literature. However, a fundamental problem still remains open, i.e., measuring the maximum capacity of taxi-based logistics at the urban scale. In this paper, we first propose an accurate and efficient measurement mechanism to tackle this problem in the Non-stop package delivery method. The basic idea is to construct a spatial-temporal graph according to the passenger demands and calculate the maximum urban capacity by combining the results of several carefully designed max-flow problems. Then, we expand our measurement mechanism to be used in other taxi-based package delivery methods after a few adaptations, including the One-hop method and the Stop-and-wait method. At last, we evaluate our measurement mechanism and compare the maximum urban capacity of various package delivery methods with a real-world dataset from an online taxi-taking platform.

The edge storage is a promising paradigm to support the Internet of Things (IoT) data storage, and is more efficient than the cloud storage in terms of the bandwidth overhead, the response latency, and so on. However, existing edge storage models cannot offer the security-aware data robustness and the adaptable data sharing among many uncertain users, due to the limitations of the utilized fault-tolerant storage technologies and the access control methods. In this article, we propose a secure and trust-oriented edge storage model, which would efficiently tackle the aforementioned two challenging issues in the IoT environment. More precisely, we first propose a robust and secure edge storage (RoSES) model using the totally local reconstruction code (TLRC) method presented in this article. It can achieve data robustness, high security, and lightweight computation at end devices. We further propose a trust-oriented data access (TODA) strategy for our RoSES model, which supports a wide and adaptable range of legitimate data accesses from uncertain requesters for IoT data sharing. We conduct extensive comparison and simulations to evaluate the performance of our new edge storage models. The results show that our model can efficiently realize the data storage, data recovery, and data sharing at the network edge, saving about 35% of storage cost and 76% degraded read latency. Besides, the data leakage probability is significantly reduced during the data storage and sharing processes.

Due to the high complexity of artificial intelligence (AI) algorithms, performing the AI tasks on the resource-limited Internet-of-Things (IoT) devices has been proved to be inadvisable. Edge computing provides an effective computing paradigm for executing AI tasks, where large numbers of AI tasks can be offloaded to the edge servers. Most of the existing works focus on achieving efficient computing offload through improving the Quality of Service (QoS), such as reducing the average server-side delay. However, we show that those efforts are inefficient due to the heterogeneous impact of delays on users' Quality of Experience (QoE). Inspired by the observations, in this article, we reconsider the scheduling method from an orthometric perspective, i.e., improving the QoE by designing a QoE-aware service-enhancement strategy for edge AI applications. Besides, multiple AI algorithms are utilized in our service model to execute the same type of tasks concurrently, thus meeting users' heterogeneity requirements of accuracy and delays. Specifically, for the online arriving AI tasks, we optimize the task allocation and scheduling strategy according to the QoE sensitivity of each task. The model can be formulated as the mixed-integer nonlinear programming problem, which is known to be NP-hard. Hence, we then propose an efficient two-phase scheduling strategy for this problem. The results of comprehensive emulations validate that our model can effectively improve the average QoE of users and achieve a higher task completion ratio.

Summary In the erasure coding storage system, it is necessary to extract multiple data blocks from other remaining storage nodes to a new node when a storage node fails, which repairs the failed data block satisfactorily. However, this would incur the incast problem at this new node. The existing solutions for the repair process in the incast problem mainly rely on path planning and resource allocation. Although these solutions improve the performance of repairing the failed data blocks, they still waste a large amount of storage and bandwidth resources unavoidably. In this paper, we propose the incast problem to be resolved economically via the in‐network aggregation. Specifically, we assume that the switches in data centers have certain data processing capabilities and can aggregate data flows efficiently. Thereafter, we propose a set of in‐network methods to repair a failed data block in the erasure coding storage systems, taking the fat‐tree data center as an example. Thus, the incast problem can be solved effectively during the data transmission process. Compared with the prior methods, our approach effectively avoids the overhead of extra path computing, as well as significantly reduces the link cost of repairing data blocks, while promising similar or faster repair speed.

The demand for package delivery services is extremely huge every day, because of the rapid development on online retailers. This leads to huge traffic congestion, resource consumption, and environmental pollution (e.g., carbon emission). However, the urban public transport system offers a large amount of under-utilized capacity outside the peak hours. In this paper, we present the city-wide package distribution problem using crowdsourced public transportation systems (CPTSs). That is, packages are delivered by carefully utilizing the considerable amount of idle capacity of the CPTS. Specifically, given a number of packages and the timetable of available CPTS trips, we optimize the package delivering scheme by determining the four identified states of any package at any time slot (waiting, riding, rewaiting, and being unloaded). The delivering scheme can be modeled as an instance of the multicommodity flow problem, and formulated by the integer linear programming techniques. We then propose an efficient heuristic solution for this NP-hard problem. Finally, this paper is validated via comprehensive emulations with a real bus transportation network.

The demand for package delivery services is extremely huge every day, because of the rapid development on online retailers. This leads to huge traffic congestion, resource consumption and environmental pollution (e.g. carbon emission). However, the urban public transport system offers a large amount of under-utilized capacity outside the peak hours. In this paper, we present the City-wide Package Distribution problem using Crowdsourced Public Transportation Systems (CPTS). That is, packages are delivered by carefully utilizing the considerable amount of idle capacity of the CPTS. Specifically, given a number of packages and the timetable of available CPTS trips, we optimize the package delivering scheme by determining the four identified states of any package at any time slot (waiting, riding, re-waiting and being unloaded). The delivering scheme can be modeled as an instance of the multi-commodity flow problem, and formulated by the Mixed Integer LinearProgramming techniques. We then propose an efficient heuristic solution for this NP-hard problem. Finally, our work is validated via comprehensive emulations with a real bus transportation network.

The Visible Light Communication (VLC) has the potential to provide dense and fast connectivity at low cost. In this paper, we propose WSWDC, a novel VLC enabled wireless small-world data center. It employs VLC links to achieve a fully wireless data center network (DCN) across racks for the first time. The using of VLC links eliminates hierarchical switches and inter-rack cables, and thus reducing hardware investment, as well as maintenance cost. More precisely, to simplify the configuration and control operations, we propose three DCN design rationales: (1) fully-wireless, all inter-rack links are wireless; (2) easy-deployable, it is not necessary to change the existing infrastructure inside data center; (3) plug-and-play, no extra centralized control operations are required. Previous proposals, however, cannot achieve the three rationales simultaneously. To this end, we first use regular VLC links to interconnect racks as a regular grid DCN. To further exploiting the benefits of VLC links, a few random VLC links are carefully introduced to update the wireless grid DCN as a wireless small-world DCN. To avoid the potential interference among VLC links, we deploy VLC transceivers at different height on the top of each rack. In this way, VLC links would not interfere with others at each height level. Moreover, we design a greedy but efficient routing method for any pair of racks using their identifiers as inputs. Comprehensive evaluation results indicate that our WSWDC exhibits good network performance.