Reducing the running time of graph algorithms is vital for tackling real-world problems such as shortest paths and matching in large-scale graphs, where path information plays a crucial role. To address this critical challenge, this paper introduces a graph restructuring algorithm that identifies bipartite cliques and replaces them with tripartite graphs. This restructuring leads to fewer edges while preserving complete graph path information, enabling the direct application of algorithms like matching and all-pairs shortest paths to achieve significant runtime reductions, especially for large, dense graphs. The running time of the proposed algorithm for a graph , with and is , which is better than , the running time of the best existing algorithm for speeding-up other graph algorithms (the Feder-Motwani (FM) algorithm), where . Both the FM algorithm and the proposed algorithm are originally formulated for bipartite graphs, but can also be applied to general directed or undirected graphs. Our extensive experimental analysis demonstrates that the proposed algorithm achieves up to 21.26% higher reduction in the number of edges and runs up to faster than the FM algorithm. On large synthetic graphs with up to 1.05 billion edges, it attains a reduction in the number of edges of up to 74.36%. On real-world graphs, it achieves a reduction in the number of edges by up to 46.8%. Furthermore, when used as a preprocessing step, our approach yields up to a speedup for the matching algorithms on large synthetic graphs, and up to a speedup for the All-Pairs Shortest Path algorithms on real-world graphs, when compared to using the given graph as input.

Ensuring low battery degradation in Autonomous Ground Robot (AGR) fleets operating in online environments (e.g., delivery services) is essential for enhancing their long-term sustainability. However, most existing studies either rely on offline methods—unsuitable for scenarios requiring real-time decisions—or focus solely on maximizing task allocation, resource utilization, or revenue, with limited consideration for battery health. Additionally, maximizing fleet sustainability requires bounded relative revenue losses from unassigned tasks within a user-defined acceptable limit to make it an attractive option for industry. To address these limitations, we propose an online task and charge allocation framework that jointly optimizes revenue generation and battery lifespan, while allowing users to explicitly constrain relative revenue losses. The framework includes three event-driven algorithms: BTC-M, which computes optimal decisions at each event, and two computationally efficient greedy variants, BTC-G and BTC-WG, which provide sub-optimal solutions with reduced overhead. We evaluate the performance of our approach under different task arrival distributions representative of real-world applications. Simulation results based on a real AGR, compared against multiple baselines, demonstrate that our framework can extend battery lifespan by up to 19% with minimal revenue loss.

Reducing the running time of graph algorithms is vital for tackling real-world problems such as shortest paths and matching in large-scale graphs, where path information plays a crucial role. To address this critical challenge, this paper introduces a graph restructuring algorithm that identifies bipartite cliques and replaces them with tripartite graphs. This restructuring leads to fewer edges while preserving complete graph path information, enabling the direct application of algorithms like matching and all-pairs shortest paths to achieve significant runtime reductions, especially for large, dense graphs. The running time of the proposed algorithm for a graph G(V,E), with |V| = n and |E| = m is O(mn^δ), which is better than O(mn^δlog^2 n), the running time of the best existing algorithm for speeding-up other graph algorithms (the Feder-Motwani () algorithm), where 0 ≤ δ≤ 1. Both the algorithm and the proposed algorithm are originally formulated for bipartite graphs, but can also be applied to general directed or undirected graphs. Our extensive experimental analysis demonstrates that the proposed algorithm achieves up to 21.26% higher reduction in the number of edges and runs up to 105.18× faster than the algorithm. On large synthetic graphs with up to 1.05 billion edges, it attains a reduction in the number of edges of up to 74.36%. On real-world graphs, it achieves a reduction in the number of edges by up to 46.8%. Furthermore, when used as a preprocessing step, our approach yields up to a 2.07× speedup for the matching algorithms on large synthetic graphs, and up to a 1.74× speedup for the All-Pairs Shortest Path algorithms on real-world graphs, when compared to using the given graph as input.

The Steiner Forest Problem is a fundamental combinatorial optimization problem in operations research and computer science. Given an undirected graph with non-negative weights for edges and a set of pairs of vertices called terminals, the Steiner Forest Problem is to find the minimum cost subgraph that connects each of the terminal pairs together. We design a family of parallel greedy algorithms based on a sequential heuristic greedy algorithm called Paired Greedy, which iteratively connects the terminal pairs that have the minimum distance. The family of parallel algorithms consists of a set of algorithms exhibiting various degrees of parallelism determined by the number of pairs that are connected in parallel in each iteration of the algorithms. We implement and run the algorithms on a multi-core system and perform an extensive experimental analysis. We analyzed the performance of the algorithms on a rich library of Steiner Forest instances with various underlying graph types. The results show that our proposed parallel algorithms achieve significant speedup with respect to the sequential Paired Greedy algorithm and provide solutions with costs that are very close to those of the solutions obtained by the sequential Paired Greedy algorithm. We provide recommendation on selecting the type of parallel algorithm and its parameters in order to achieve the most efficient results for each class of instances.

Edge computing allows end-user devices to offload heavy computation to nearby edge servers for reduced latency, maximized profit, and/or minimized energy consumption. Data-dependent tasks that analyze locally-acquired sensing data are one of the most common candidates for task offloading in edge computing. As a result, the total latency and network load are affected by the total amount of data transferred from end-user devices to the selected edge servers. Most existing solutions for task allocation in edge computing do not take into consideration that some user tasks may actually operate on the same data items. Making the task allocation algorithm aware of the existing data sharing characteristics of tasks can help reduce network load at a negligible profit loss by allocating more tasks sharing data on the same server. In this paper, we formulate the data sharing-aware task allocation problem that make decisions on task allocation for maximized profit and minimized network load by taking into account the data-sharing characteristics of tasks. In addition, because the problem is NP-hard, we design the DSTA algorithm, which finds a solution to the problem in polynomial time. We analyze the performance of the proposed algorithm against a state-of-the-art baseline that only maximizes profit. Our extensive analysis shows that DSTA leads to about 8 times lower data load on the network while being within 1.03 times of the total profit on average compared to the state-of-the-art.

Many of the tasks offloaded to edge devices perform computation to analyze sensing data. Transferring this data from end-user devices to edge servers leads to increased latency and congestion in the edge network. Since many of the offloaded tasks may require processing the same data items, the task allocation algorithms can exploit this to reduce the traffic in the networks and the number of edge servers needed to execute the tasks. Therefore, in this paper we design online algorithms for task allocation in edge computing systems that take into account the sharing of data among the tasks offloaded to the same server. We perform an extensive performance analysis by comparing our proposed algorithms with several sharing-oblivious baseline algorithms. The results show that our algorithms are able to reduce the amount of data transferred in the network by 30.2% to 92.8% and the number of utilized servers by 1% to 82.8% compared to the sharing-oblivious baseline algorithms.

This paper will present the development of an ASIP design and it's toolchain for integrating a convolutional neural network in the ONNX format that works on the MNIST dataset. Additionally, it will present the results of the design's deployment onto a Xilinx Zynq Ultra-Scale+ MPSoC ZCU102 FPGA. As a toolchain, the LLVM umbrella project is being used. LLVM started as a compiler project, aiming for modularity but later became an umbrella project due to the large number of contributions and subprojects. The three main components are the ONNX-MLIR project, the LLVM main project (mainly the clangd, the optimizer and a specific RISC-V backend developed by us) and an HLS Simulator project called Comet, used to design the architecture. After a series of modifications, Comet was renamed to AIDA.

Ensuring low battery degradation of Autonomous Ground Robot (AGR) fleets operating in online scenarios (e.g., delivery) through an efficient task and charge scheduling strategy can significantly enhance their long-term sustainability. Most existing studies are either based on offline methods, which are unsuitable for online scenarios requiring instant decisions, or concentrated on maximizing task allocation, resource usage, and/or revenues without considering the battery health. To overcome these limitations, this paper proposes a family of two joint task allocation and charge scheduling algorithms that activate at specific events to maximize the total revenue while minimizing the battery degradation of the fleet in online scenarios. Utility functions are defined to trade off revenues for battery degradation while deciding, for all the AGRs in the fleet, how to allocate tasks, charging stations, and idle periods. The first algorithm is based on the Kuhn-Munkres approach that makes decisions at each event optimally. The second algorithm utilizes a greedy approach achieving a sub-optimal solution with reduced computational overhead. Our results, obtained through extensive simulations based on a real AGR against several baselines, show that it is possible to achieve up to 20% longer battery lifespan with minimal revenue losses.

Autonomous mobile robots (AMRs) are capable of carrying out operations continuously for 24/7, which enables them to optimize tasks, increase throughput, and meet demanding operational requirements. To ensure seamless and uninterrupted operations, an effective coordination of task allocation and charging schedules is crucial while considering the preservation of battery sustainability. Moreover, regular preventive maintenance plays an important role in enhancing the robustness of AMRs against hardware failures and abnormalities during task execution. However, existing works do not consider the influence of properly scheduling AMR maintenance on both task downtime and battery lifespan. In this paper, we propose MTC , a maintenance-aware task and charging scheduler designed for fleets of AMR operating continuously in highly automated environments. MTC leverages Linear Programming (LP) to first help decide the best time to schedule maintenance for a given set of AMRs. Subsequently, the Kuhn-Munkres algorithm, a variant of the Hungarian algorithm, is used to finalize task assignments and carry out the charge scheduling to minimize the combined cost of task downtime and battery degradation. Experimental results demonstrate the effectiveness of MTC , reducing the combined total cost up to 3.45 times and providing up to 68% improvement in battery capacity degradation compared to the baselines.

Monte-Carlo Tree Search (MCTS) is an adaptive and heuristic tree-search algorithm designed to uncover sub-optimal actions at each decision-making point. This method progressively constructs a search tree by gathering samples throughout its execution. Predominantly applied within the realm of gaming, MCTS has exhibited exceptional achievements. Additionally, it has displayed promising outcomes when employed to solve NP-hard combinatorial optimization problems. MCTS has been adapted for distributed-memory parallel platforms. The primary challenges associated with distributed-memory parallel MCTS are the substantial communication overhead and the necessity to balance the computational load among various processes. In this work, we introduce a novel distributed-memory parallel MCTS algorithm with partial backpropagations, referred to as Parallel Partial-Backpropagation MCTS (PPB-MCTS). Our design approach aims to significantly reduce the communication overhead while maintaining, or even slightly improving, the performance in the context of combinatorial optimization problems. To address the communication overhead challenge, we propose a strategy involving transmitting an additional backpropagation message. This strategy avoids attaching an information table to the communication messages exchanged by the processes, thus reducing the communication overhead. Furthermore, this approach contributes to enhancing the decision-making accuracy during the selection phase. The load balancing issue is also effectively addressed by implementing a shared transposition table among the parallel processes. Furthermore, we introduce two primary methods for managing duplicate states within distributed-memory parallel MCTS, drawing upon techniques utilized in addressing duplicate states within sequential MCTS. Duplicate states can transform the conventional search tree into a Directed Acyclic Graph (DAG). To evaluate the performance of our proposed parallel algorithm, we conduct an extensive series of experiments on solving instances of the Job-Shop Scheduling Problem (JSSP) and the Weighted Set-Cover Problem (WSCP). These problems are recognized for their complexity and classified as NP-hard combinatorial optimization problems with considerable relevance within industrial applications. The experiments are performed on a cluster of computers with many cores. The empirical results highlight the enhanced scalability of our algorithm compared to that of the existing distributed-memory parallel MCTS algorithms. As the number of processes increases, our algorithm demonstrates increased rollout efficiency while maintaining an improved load balance across processes.

The matching problem formulated as Maximum Cardinality Matching in General Graphs (MCMGG) finds the largest matching on graphs without restrictions. The Micali-Vazirani algorithm has the best asymptotic complexity for solving MCMGG when the graphs are sparse. Parallelizing matching in general graphs on the GPU is difficult for multiple reasons. First, the augmenting path procedure is highly recursive, and NVIDIA GPUs use registers to store kernel arguments, which eventually spill into cached device memory, with a performance penalty. Second, extracting parallelism from the matching process requires partitioning the graph to avoid any overlapping augmenting paths. We propose an implementation of the Micali-Vazirani algorithm which identifies bridge edges using thread-parallel breadth-first search, followed by block-parallel path augmentation and blossom contraction. Augmenting path and Union-find methods were implemented as stack-based iterative methods, with a stack allocated in shared memory. Our experimentation shows that compared to the serial implementation, our approach results in up to 15-fold speed-up for very sparse regular graphs, up to 5-fold slowdown for denser regular graphs, and finally a 50-fold slowdown for power-law distributed Kronecker graphs. This implementation has been open-sourced for further research on developing combinatorial graph algorithms on GPUs.

The flow shop scheduling problem is one of the most complex and widely applicable scheduling problem. In this paper, we design efficient parallel algorithms for solving large-size non-permutation flow shop scheduling problems by leveraging the huge amount of computing power of the current multi-core computing systems. We design two parallel algorithms based on the Shifting Bottleneck heuristic. The first one is a coarse-grained parallel algorithm that is suitable for execution on multi-core systems with a small number of cores, while the second one is a fine-grained parallel algorithm suitable for multi-core systems with a large number of cores. We perform an extensive experimental analysis to evaluate the performance of the proposed algorithms for instances of various sizes. The results show that the proposed algorithms can solve large-size instances of the problem in a reasonable amount of time and obtain solutions that are within acceptable distance from the lower bounds. The proposed parallel algorithms achieve good speedup with respect to the serial variants of the algorithms.

Future private and public transportation will be dominated by Autonomous Vehicles (AV), which are potentially safer than regular vehicles. However, ensuring good performance for the autonomous features requires fast processing of heavy computational tasks. Providing each AV with powerful enough computing resources is certainly a practical solution but may result in increased AV cost and decreased driving range. An alternative solution being explored in research is to install low-power computing hardware on each AV and offload the heavy tasks to powerful nearby edge servers. In this case, the AV's reaction time depends on how quickly the navigation tasks are completed in the edge server. To reduce task completion latency, the edge servers must be equipped with enough network and computing resources to handle the vehicle demands. However, this demand shows large spatio-temporal variations. Thus, deploying the same amount of resources in different locations may lead to unnecessary resource over-provisioning. Taking these challenges into consideration, in this paper, we discuss the implications of deploying different amounts of resources in different city areas based on real traffic data to sustain peak versus average demand. Because deploying edge resources to handle the average demand leads to lower deployment costs and better system utilization, we then investigate how peak-hour demand affect the safe travel time of AVs and whether current turn-by-turn navigation apps would still provide the fastest travel route. The insights and findings of this paper will inspire new research that can considerably speed up the deployment of edge-assisted AVs in our society.

In Vehicular Edge Computing (VEC) systems, the computing resources of connected Electric Vehicles (EV) are used to fulfill the low-latency computation requirements of vehicles. However, local execution of heavy workloads may drain a considerable amount of energy in EVs. One promising way to improve the energy efficiency is to share and coordinate computing resources among connected EVs. However, the uncertainties in the future location of vehicles make it hard to decide which vehicles participate in resource sharing and how long they share their resources so that all participants benefit from resource sharing. In this paper, we propose VECMAN, a framework for energy-aware resource management in VEC systems composed of two algorithms: (i) a resource selector algorithm that determines the participating vehicles and the duration of resource sharing period; and (ii) an energy manager algorithm that manages computing resources of the participating vehicles with the aim of minimizing the computational energy consumption. We evaluate the proposed algorithms and show that they considerably reduce the vehicles’ computational energy consumption compared to the state-of-the-art baselines. Specifically, our algorithms achieve between 7 and 18 percent energy savings compared to a baseline that executes workload locally and an average of 13 percent energy savings compared to a baseline that offloads vehicles’ workloads to RSUs.

In the Steiner Forest problem, we are given an undirected graph with non-negative weights for edges, a set of pairs of vertices, called terminals, and the goal is to find the minimum cost subgraph that connects each of the terminal pairs together. There exist several sequential heuristic and approximation algorithms for the Steiner Forest problem. In practice, the primal-dual 2-approximation algorithm is one of the fastest and obtains solutions that are very close to the optimal solution. In this paper, we design a practical parallel approximation algorithm based on the primal-dual sequential algorithm. The parallel algorithm maintains the approximation guarantees of the sequential primal-dual algorithm and it is specifically designed for execution on multi-core computers. We implement and run the parallel algorithm on a multi-core system with a large number of cores and perform an extensive experimental performance analysis on randomly generated graphs. The results show that our proposed parallel approximation algorithm achieves a significant speedup with respect to the sequential primal-dual algorithm.

We introduce a family of fast parallel greedy algorithms for the Steiner Forest Problem, a fundamental combinatorial optimization problem in graphs. Given an undirected graph with non-negative weights for edges and a set of pairs of vertices called terminals, the Steiner Forest Problem is to find the minimum cost subgraph that connects each of the terminal pairs together. We design a family of parallel algorithms based on a sequential heuristic greedy algorithm called Paired Greedy which iteratively connects the terminal pairs that have the minimum distance. The family of parallel algorithms consists of a set of algorithms exhibiting various degrees of parallelism determined by the number of pairs that are connected in parallel in each iteration of the algorithms. We implement and run the algorithms on a multi-core system and perform an extensive experimental analysis. The results show that our proposed parallel algorithms achieve significant speedup with respect to the sequential Paired Greedy algorithm and provide solutions with costs that are very close to those of the solutions obtained by the sequential Paired Greedy algorithm.

We design a parallel algorithm for the Constrained Shortest Path (CSP) problem. The CSP problem is known to be NP-hard and there exists a pseudo-polynomial time sequential algorithm that solves it. To design the parallel algorithm, we extend the techniques used in the design of the Δ-stepping algorithm for the single-source shortest paths problem.

In the Steiner forest problem, we are given a set of terminal pairs and need to find the minimum cost subgraph that connects each of the terminal pairs together. Motivated by the recent work on greedy approximation algorithms for the Steiner forest, we provide efficient implementations of existing approximation algorithms and conduct a thorough experimental study to characterize their performance. We consider several approximation algorithms: the influential primal-dual 2-approximation algorithm due to Agrawal, Klein, and Ravi, the greedy algorithm due to Gupta and Kumar, and a randomized algorithm based on probabilistic approximation by tree metrics. We also consider the simplest heuristic greedy algorithm for the problem, which picks the closest unconnected pair of terminals and connects it using the shortest path between the terminals in the current graph. To characterize the performance of the algorithms, we created a new library with more than one thousand Steiner forest problem instances and conducted an extensive experimental analysis on those instances. Our analysis reveals that for the majority of instances the primal-dual algorithm is the fastest among all the algorithms considered here, and obtains solutions that are very close to the optimal solutions obtained by solving the integer program formulation of the problem.

The papers in this special section focus on energy efficient edge computing. The future increase in the amount of data and workloads generated by Internet of Things (IoT) devices and connected sensors will lead to the necessity to move computational nodes from the cloud data centers closer to the data source, i.e., at the edge of the cloud, for reduced latency. An edge system is composed of any computing and networking resources along the path between data sources and cloud data centers. Depending on the specific computing needs, edge computing devices can use either a wireless or a wired connection to exchange messages with the data sources. IoT devices and sensors can then exploit the hierarchical structure of the edge and cloud system to analyze the collected data and provide useful information to users in a timely manner. For example, wearable sensors could use the computing resources of the user’s smartphone, laptop, or even smart vehicle to analyze the collected data. Because a large majority of edge devices are battery operated and have limited connectivity, the energy efficiency of computation becomes critical. To this end, it is important to minimize the energy consumption of all the components of an edge system, including sensors, IoT devices, edge nodes, and network devices while guaranteeing the desired performance. For this special section we selected eight articles that cover experimental, conceptual, and theoretical contributions to energy-efficient edge computing.

In this article, we address the Multi-Component Application Placement Problem ( ${\sf MCAPP}$ ) in Mobile Edge Computing (MEC) systems. We formulate this problem as a Mixed Integer Non-Linear Program (MINLP) with the objective of minimizing the total cost of running the applications. In our formulation, we take into account two important and challenging characteristics of MEC systems, the mobility of users and the network capabilities. We analyze the complexity of ${\sf MCAPP}$ and prove that it is $NP$ -hard, that is, finding the optimal solution in reasonable amount of time is infeasible. We design two algorithms, one based on matching and local search and one based on a greedy approach, and evaluate their performance by conducting an extensive experimental analysis driven by two types of user mobility models, real-life mobility traces and random-walk. The results show that the proposed algorithms obtain near-optimal solutions and require small execution times for reasonably large problem instances.